141b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm/** @file 241b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm Long (arbitrary precision) integer object implementation. 341b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm 441b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm Copyright (c) 2011, Intel Corporation. All rights reserved.<BR> 541b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm This program and the accompanying materials are licensed and made available under 641b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm the terms and conditions of the BSD License that accompanies this distribution. 741b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm The full text of the license may be found at 841b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm http://opensource.org/licenses/bsd-license. 941b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm 1041b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 1141b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 1241b152c5f6ec3a5a6e51b4f8f0f90291a5895edcdarylm**/ 136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* XXX The functional organization of this file is terrible */ 156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include "Python.h" 176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include "longintrepr.h" 186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include "structseq.h" 196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include <float.h> 216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include <ctype.h> 226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#include <stddef.h> 236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* For long multiplication, use the O(N**2) school algorithm unless 256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * both operands contain more than KARATSUBA_CUTOFF digits (this 266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * being an internal Python long digit, in base PyLong_BASE). 276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define KARATSUBA_CUTOFF 70 296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF) 306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* For exponentiation, use the binary left-to-right algorithm 326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * unless the exponent contains more than FIVEARY_CUTOFF digits. 336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * In that case, do 5 bits at a time. The potential drawback is that 346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * a table of 2**5 intermediate results is computed. 356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define FIVEARY_CUTOFF 8 376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifndef ABS 396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm #define ABS(x) ((x) < 0 ? -(x) : (x)) 406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifndef MAX 436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm #define MAX(x, y) ((x) < (y) ? (y) : (x)) 446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifndef MIN 476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm #define MIN(x, y) ((x) > (y) ? (y) : (x)) 486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define SIGCHECK(PyTryBlock) \ 516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { \ 526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (--_Py_Ticker < 0) { \ 536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _Py_Ticker = _Py_CheckInterval; \ 546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyErr_CheckSignals()) PyTryBlock \ 556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } \ 566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while(0) 576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Normalize (remove leading zeros from) a long int object. 596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Doesn't attempt to free the storage--in most cases, due to the nature 606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm of the algorithms used, this could save at most be one word anyway. */ 616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_normalize(register PyLongObject *v) 646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t j = ABS(Py_SIZE(v)); 666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i = j; 676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (i > 0 && v->ob_digit[i-1] == 0) 696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm --i; 706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i != j) 716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i; 726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return v; 736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Allocate a new long int object with size digits. 766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Return NULL and set exception if we run out of memory. */ 776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define MAX_LONG_DIGITS \ 796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ((PY_SSIZE_T_MAX - offsetof(PyLongObject, ob_digit))/sizeof(digit)) 806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLongObject * 826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_New(Py_ssize_t size) 836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size > (Py_ssize_t)MAX_LONG_DIGITS) { 856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "too many digits in integer"); 876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* coverity[ampersand_in_size] */ 906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* XXX(nnorwitz): PyObject_NEW_VAR / _PyObject_VAR_SIZE need to detect 916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm overflow */ 926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size); 936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_Copy(PyLongObject *src) 976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *result; 996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 1006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(src != NULL); 1026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = src->ob_size; 1036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) 1046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -(i); 1056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = _PyLong_New(i); 1066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (result != NULL) { 1076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result->ob_size = src->ob_size; 1086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) 1096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result->ob_digit[i] = src->ob_digit[i]; 1106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)result; 1126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 1136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C long int */ 1156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 1176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromLong(long ival) 1186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 1196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v; 1206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long abs_ival; 1216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long t; /* unsigned so >> doesn't propagate sign bit */ 1226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int ndigits = 0; 1236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int negative = 0; 1246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ival < 0) { 1266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* if LONG_MIN == -LONG_MAX-1 (true on most platforms) then 1276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ANSI C says that the result of -ival is undefined when ival 1286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm == LONG_MIN. Hence the following workaround. */ 1296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm abs_ival = (unsigned long)(-1-ival) + 1; 1306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negative = 1; 1316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 1336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm abs_ival = (unsigned long)ival; 1346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Count the number of Python digits. 1376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm We used to pick 5 ("big enough for anything"), but that's a 1386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm waste of time and space given that 5*15 = 75 bits are rarely 1396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm needed. */ 1406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = abs_ival; 1416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 1426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++ndigits; 1436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 1446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndigits); 1466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v != NULL) { 1476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *p = v->ob_digit; 1486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v->ob_size = negative ? -ndigits : ndigits; 1496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = abs_ival; 1506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 1516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p++ = (digit)(t & PyLong_MASK); 1526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 1536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)v; 1566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 1576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C unsigned long int */ 1596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 1616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromUnsignedLong(unsigned long ival) 1626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 1636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v; 1646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long t; 1656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int ndigits = 0; 1666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Count the number of Python digits. */ 1686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = (unsigned long)ival; 1696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 1706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++ndigits; 1716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 1726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndigits); 1746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v != NULL) { 1756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *p = v->ob_digit; 1766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = ndigits; 1776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (ival) { 1786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p++ = (digit)(ival & PyLong_MASK); 1796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ival >>= PyLong_SHIFT; 1806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)v; 1836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 1846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C double */ 1866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 1886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromDouble(double dval) 1896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 1906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v; 1916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double frac; 1926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int i, ndig, expo, neg; 1936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm neg = 0; 1946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_IS_INFINITY(dval)) { 1956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 1966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "cannot convert float infinity to integer"); 1976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 1986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 1996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_IS_NAN(dval)) { 2006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, 2016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "cannot convert float NaN to integer"); 2026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 2036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (dval < 0.0) { 2056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm neg = 1; 2066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dval = -dval; 2076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */ 2096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (expo <= 0) 2106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromLong(0L); 2116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndig = (expo-1) / PyLong_SHIFT + 1; /* Number of 'digits' in result */ 2126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndig); 2136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v == NULL) 2146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 2156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm frac = ldexp(frac, (expo-1) % PyLong_SHIFT + 1); 2166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = ndig; --i >= 0; ) { 2176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit bits = (digit)frac; 2186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v->ob_digit[i] = bits; 2196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm frac = frac - (double)bits; 2206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm frac = ldexp(frac, PyLong_SHIFT); 2216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (neg) 2236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = -(Py_SIZE(v)); 2246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)v; 2256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 2266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Checking for overflow in PyLong_AsLong is a PITA since C doesn't define 2286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * anything about what happens when a signed integer operation overflows, 2296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * and some compilers think they're doing you a favor by being "clever" 2306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * then. The bit pattern for the largest postive signed long is 2316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * (unsigned long)LONG_MAX, and for the smallest negative signed long 2326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * it is abs(LONG_MIN), which we could write -(unsigned long)LONG_MIN. 2336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * However, some other compilers warn about applying unary minus to an 2346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * unsigned operand. Hence the weird "0-". 2356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 2366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN) 2376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define PY_ABS_SSIZE_T_MIN (0-(size_t)PY_SSIZE_T_MIN) 2386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C long int from a Python long or Python int object. 2406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm On overflow, returns -1 and sets *overflow to 1 or -1 depending 2416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm on the sign of the result. Otherwise *overflow is 0. 2426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm For other errors (e.g., type error), returns -1 and sets an error 2446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm condition. 2456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm*/ 2466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong 2486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsLongAndOverflow(PyObject *vv, int *overflow) 2496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 2506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* This version by Tim Peters */ 2516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 2526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long x, prev; 2536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long res; 2546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 2556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 2566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int do_decref = 0; /* if nb_int was called */ 2576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = 0; 2596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL) { 2606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 2616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 2626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if(PyInt_Check(vv)) 2656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_AsLong(vv); 2666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyLong_Check(vv)) { 2686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyNumberMethods *nb; 2696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nb = vv->ob_type->tp_as_number; 2706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (nb == NULL || nb->nb_int == NULL) { 2716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, 2726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "an integer is required"); 2736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 2746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vv = (*nb->nb_int) (vv); 2766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL) 2776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 2786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do_decref = 1; 2796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if(PyInt_Check(vv)) { 2806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = PyInt_AsLong(vv); 2816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto exit; 2826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyLong_Check(vv)) { 2846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(vv); 2856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, 2866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "nb_int should return int object"); 2876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 2886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 2906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = -1; 2926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 2936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = Py_SIZE(v); 2946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm switch (i) { 2966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case -1: 2976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = -(sdigit)v->ob_digit[0]; 2986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 2996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case 0: 3006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = 0; 3016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 3026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case 1: 3036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = v->ob_digit[0]; 3046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 3056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm default: 3066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 3076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 3086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 3096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 3106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -(i); 3116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 3136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm prev = x; 3146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) + v->ob_digit[i]; 3156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((x >> PyLong_SHIFT) != prev) { 3166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = sign; 3176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto exit; 3186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Haven't lost any bits, but casting to long requires extra 3216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * care (see comment above). 3226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 3236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x <= (unsigned long)LONG_MAX) { 3246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = (long)x * sign; 3256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (sign < 0 && x == PY_ABS_LONG_MIN) { 3276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = LONG_MIN; 3286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 3306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = sign; 3316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* res is already set to -1 */ 3326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm exit: 3356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (do_decref) { 3366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(vv); 3376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return res; 3396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 3406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C long int from a long int object. 3426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns -1 and sets an error condition if overflow occurs. */ 3436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong 3456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsLong(PyObject *obj) 3466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 3476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int overflow; 3486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long result = PyLong_AsLongAndOverflow(obj, &overflow); 3496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (overflow) { 3506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* XXX: could be cute and give a different 3516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm message for overflow == -1 */ 3526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 3536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "Python int too large to convert to C long"); 3546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return result; 3566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 3576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a Py_ssize_t from a long int object. 3596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns -1 and sets an error condition if overflow occurs. */ 3606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPy_ssize_t 3626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsSsize_t(PyObject *vv) { 3636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 3646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t x, prev; 3656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 3666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 3676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL || !PyLong_Check(vv)) { 3696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 3706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 3716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 3736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = v->ob_size; 3746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 3756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 3766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 3776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 3786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -(i); 3796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 3816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm prev = x; 3826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 3836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((x >> PyLong_SHIFT) != prev) 3846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 3856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Haven't lost any bits, but casting to a signed type requires 3876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * extra care (see comment above). 3886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 3896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x <= (size_t)PY_SSIZE_T_MAX) { 3906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (Py_ssize_t)x * sign; 3916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (sign < 0 && x == PY_ABS_SSIZE_T_MIN) { 3936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PY_SSIZE_T_MIN; 3946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 3956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* else overflow */ 3966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm overflow: 3986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 3996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long int too large to convert to int"); 4006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 4016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 4026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C unsigned long int from a long int object. 4046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns -1 and sets an error condition if overflow occurs. */ 4056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmunsigned long 4076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsUnsignedLong(PyObject *vv) 4086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 4096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 4106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long x, prev; 4116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 4126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL || !PyLong_Check(vv)) { 4146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv != NULL && PyInt_Check(vv)) { 4156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long val = PyInt_AsLong(vv); 4166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (val < 0) { 4176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 4186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "can't convert negative value " 4196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "to unsigned long"); 4206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 4216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return val; 4236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 4256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 4266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 4286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = Py_SIZE(v); 4296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 4306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 4316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 4326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "can't convert negative value to unsigned long"); 4336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 4346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 4366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm prev = x; 4376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((x >> PyLong_SHIFT) != prev) { 4396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 4406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long int too large to convert"); 4416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 4426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return x; 4456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 4466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C unsigned long int from a long int object, ignoring the high bits. 4486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns -1 and sets an error condition if an error occurs. */ 4496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmunsigned long 4516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsUnsignedLongMask(PyObject *vv) 4526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 4536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 4546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long x; 4556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 4566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 4576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL || !PyLong_Check(vv)) { 4596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv != NULL && PyInt_Check(vv)) 4606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_AsUnsignedLongMask(vv); 4616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 4626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 4636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 4656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = v->ob_size; 4666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 4676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 4686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 4696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 4706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -i; 4716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 4736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 4756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return x * sign; 4766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 4776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmint 4796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_Sign(PyObject *vv) 4806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 4816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v = (PyLongObject *)vv; 4826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(v != NULL); 4846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyLong_Check(v)); 4856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1); 4876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 4886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmsize_t 4906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_NumBits(PyObject *vv) 4916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 4926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v = (PyLongObject *)vv; 4936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t result = 0; 4946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t ndigits; 4956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(v != NULL); 4976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyLong_Check(v)); 4986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndigits = ABS(Py_SIZE(v)); 4996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 5006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ndigits > 0) { 5016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit msd = v->ob_digit[ndigits - 1]; 5026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = (ndigits - 1) * PyLong_SHIFT; 5046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (result / PyLong_SHIFT != (size_t)(ndigits - 1)) 5056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Overflow; 5066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 5076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++result; 5086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (result == 0) 5096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Overflow; 5106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm msd >>= 1; 5116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while (msd); 5126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return result; 5146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Overflow: 5166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, "long has too many bits " 5176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "to express in a platform size_t"); 5186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (size_t)-1; 5196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 5206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 5226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_FromByteArray(const unsigned char* bytes, size_t n, 5236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int little_endian, int is_signed) 5246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 5256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const unsigned char* pstartbyte; /* LSB of bytes */ 5266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int incr; /* direction to move pstartbyte */ 5276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const unsigned char* pendbyte; /* MSB of bytes */ 5286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t numsignificantbytes; /* number of bytes that matter */ 5296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t ndigits; /* number of Python long digits */ 5306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject* v; /* result */ 5316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t idigit = 0; /* next free index in v->ob_digit */ 5326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (n == 0) 5346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromLong(0L); 5356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (little_endian) { 5376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pstartbyte = bytes; 5386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pendbyte = bytes + n - 1; 5396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm incr = 1; 5406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 5426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pstartbyte = bytes + n - 1; 5436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pendbyte = bytes; 5446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm incr = -1; 5456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (is_signed) 5486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm is_signed = *pendbyte >= 0x80; 5496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Compute numsignificantbytes. This consists of finding the most 5516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm significant byte. Leading 0 bytes are insignificant if the number 5526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm is positive, and leading 0xff bytes if negative. */ 5536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { 5546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t i; 5556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const unsigned char* p = pendbyte; 5566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const int pincr = -incr; /* search MSB to LSB */ 5576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const unsigned char insignficant = is_signed ? 0xff : 0x00; 5586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < n; ++i, p += pincr) { 5606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*p != insignficant) 5616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 5626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm numsignificantbytes = n - i; 5646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so 5656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm actually has 2 significant bytes. OTOH, 0xff0001 == 5666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm -0x00ffff, so we wouldn't *need* to bump it there; but we 5676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do for 0xffff = -0x0001. To be safe without bothering to 5686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm check every case, bump it regardless. */ 5696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (is_signed && numsignificantbytes < n) 5706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++numsignificantbytes; 5716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* How many Python long digits do we need? We have 5746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8*numsignificantbytes bits, and each Python long digit has 5756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLong_SHIFT bits, so it's the ceiling of the quotient. */ 5766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* catch overflow before it happens */ 5776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (numsignificantbytes > (PY_SSIZE_T_MAX - PyLong_SHIFT) / 8) { 5786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 5796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "byte array too long to convert to int"); 5806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 5816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 5826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndigits = (numsignificantbytes * 8 + PyLong_SHIFT - 1) / PyLong_SHIFT; 5836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndigits); 5846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v == NULL) 5856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 5866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Copy the bits over. The tricky parts are computing 2's-comp on 5886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the fly for signed numbers, and dealing with the mismatch between 5896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8-bit bytes and (probably) 15-bit Python digits.*/ 5906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { 5916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t i; 5926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits carry = 1; /* for 2's-comp calculation */ 5936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits accum = 0; /* sliding register */ 5946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned int accumbits = 0; /* number of bits in accum */ 5956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const unsigned char* p = pstartbyte; 5966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < numsignificantbytes; ++i, p += incr) { 5986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits thisbyte = *p; 5996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Compute correction for 2's comp, if needed. */ 6006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (is_signed) { 6016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm thisbyte = (0xff ^ thisbyte) + carry; 6026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = thisbyte >> 8; 6036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm thisbyte &= 0xff; 6046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Because we're going LSB to MSB, thisbyte is 6066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm more significant than what's already in accum, 6076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm so needs to be prepended to accum. */ 6086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (twodigits)thisbyte << accumbits; 6096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits += 8; 6106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (accumbits >= PyLong_SHIFT) { 6116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* There's enough to fill a Python digit. */ 6126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(idigit < ndigits); 6136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v->ob_digit[idigit] = (digit)(accum & PyLong_MASK); 6146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++idigit; 6156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum >>= PyLong_SHIFT; 6166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits -= PyLong_SHIFT; 6176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(accumbits < PyLong_SHIFT); 6186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(accumbits < PyLong_SHIFT); 6216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (accumbits) { 6226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(idigit < ndigits); 6236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v->ob_digit[idigit] = (digit)accum; 6246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++idigit; 6256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = is_signed ? -idigit : idigit; 6296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)long_normalize(v); 6306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 6316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmint 6336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_AsByteArray(PyLongObject* v, 6346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned char* bytes, size_t n, 6356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int little_endian, int is_signed) 6366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 6376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; /* index into v->ob_digit */ 6386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t ndigits; /* |v->ob_size| */ 6396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits accum; /* sliding register */ 6406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned int accumbits; /* # bits in accum */ 6416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */ 6426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry; /* for computing 2's-comp */ 6436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t j; /* # bytes filled */ 6446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned char* p; /* pointer to next byte in bytes */ 6456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int pincr; /* direction to move p */ 6466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(v != NULL && PyLong_Check(v)); 6486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(v) < 0) { 6506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndigits = -(Py_SIZE(v)); 6516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!is_signed) { 6526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 6536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "can't convert negative long to unsigned"); 6546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 6556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do_twos_comp = 1; 6576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 6596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndigits = Py_SIZE(v); 6606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do_twos_comp = 0; 6616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (little_endian) { 6646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p = bytes; 6656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pincr = 1; 6666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 6686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p = bytes + n - 1; 6696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pincr = -1; 6706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Copy over all the Python digits. 6736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm It's crucial that every Python digit except for the MSD contribute 6746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm exactly PyLong_SHIFT bits to the total, so first assert that the long is 6756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm normalized. */ 6766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 6776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm j = 0; 6786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum = 0; 6796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits = 0; 6806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = do_twos_comp ? 1 : 0; 6816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < ndigits; ++i) { 6826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit thisdigit = v->ob_digit[i]; 6836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (do_twos_comp) { 6846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm thisdigit = (thisdigit ^ PyLong_MASK) + carry; 6856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = thisdigit >> PyLong_SHIFT; 6866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm thisdigit &= PyLong_MASK; 6876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 6886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Because we're going LSB to MSB, thisdigit is more 6896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm significant than what's already in accum, so needs to be 6906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm prepended to accum. */ 6916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (twodigits)thisdigit << accumbits; 6926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 6936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The most-significant digit may be (probably is) at least 6946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm partly empty. */ 6956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i == ndigits - 1) { 6966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Count # of sign bits -- they needn't be stored, 6976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * although for signed conversion we need later to 6986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * make sure at least one sign bit gets stored. */ 6996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit s = do_twos_comp ? thisdigit ^ PyLong_MASK : thisdigit; 7006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (s != 0) { 7016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm s >>= 1; 7026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits++; 7036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 7066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits += PyLong_SHIFT; 7076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Store as many bytes as possible. */ 7096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (accumbits >= 8) { 7106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (j >= n) 7116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Overflow; 7126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++j; 7136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p = (unsigned char)(accum & 0xff); 7146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p += pincr; 7156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits -= 8; 7166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum >>= 8; 7176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Store the straggler (if any). */ 7216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(accumbits < 8); 7226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry == 0); /* else do_twos_comp and *every* digit was 0 */ 7236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (accumbits > 0) { 7246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (j >= n) 7256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Overflow; 7266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++j; 7276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (do_twos_comp) { 7286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Fill leading bits of the byte with sign bits 7296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (appropriately pretending that the long had an 7306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm infinite supply of sign bits). */ 7316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (~(twodigits)0) << accumbits; 7326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p = (unsigned char)(accum & 0xff); 7346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p += pincr; 7356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (j == n && n > 0 && is_signed) { 7376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The main loop filled the byte array exactly, so the code 7386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm just above didn't get to ensure there's a sign bit, and the 7396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm loop below wouldn't add one either. Make sure a sign bit 7406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm exists. */ 7416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned char msb = *(p - pincr); 7426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign_bit_set = msb >= 0x80; 7436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(accumbits == 0); 7446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (sign_bit_set == do_twos_comp) 7456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 7466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 7476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Overflow; 7486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Fill remaining bytes with copies of the sign bit. */ 7516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { 7526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned char signbyte = do_twos_comp ? 0xffU : 0U; 7536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for ( ; j < n; ++j, p += pincr) 7546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p = signbyte; 7556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 7566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 7586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Overflow: 7606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, "long too big to convert"); 7616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 7626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 7646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long (or int) object from a C pointer */ 7666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 7686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromVoidPtr(void *p) 7696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 7706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if SIZEOF_VOID_P <= SIZEOF_LONG 7716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((long)p < 0) 7726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromUnsignedLong((unsigned long)p); 7736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromLong((long)p); 7746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#else 7756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifndef HAVE_LONG_LONG 7776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long" 7786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 7796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 7806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm# error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 7816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 7826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* optimize null pointers */ 7836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (p == NULL) 7846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromLong(0); 7856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p); 7866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 7886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 7896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C pointer from a long object (or an int object in some cases) */ 7916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 7926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmvoid * 7936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsVoidPtr(PyObject *vv) 7946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 7956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* This function will allow int or long objects. If vv is neither, 7966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm then the PyLong_AsLong*() functions will raise the exception: 7976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyExc_SystemError, "bad argument to internal function" 7986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 7996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if SIZEOF_VOID_P <= SIZEOF_LONG 8006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long x; 8016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(vv)) 8036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyInt_AS_LONG(vv); 8046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyLong_AsLong(vv); 8066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 8076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyLong_AsUnsignedLong(vv); 8086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#else 8096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifndef HAVE_LONG_LONG 8116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long" 8126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 8136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 8146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 8156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 8166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PY_LONG_LONG x; 8176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(vv)) 8196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyInt_AS_LONG(vv); 8206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyLong_AsLongLong(vv); 8226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 8236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyLong_AsUnsignedLongLong(vv); 8246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 8266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == -1 && PyErr_Occurred()) 8286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 8296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (void *)x; 8306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 8316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifdef HAVE_LONG_LONG 8336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later 8356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * rewritten to use the newer PyLong_{As,From}ByteArray API. 8366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 8376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one 8396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define PY_ABS_LLONG_MIN (0-(unsigned PY_LONG_LONG)PY_LLONG_MIN) 8406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C PY_LONG_LONG int. */ 8426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 8446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromLongLong(PY_LONG_LONG ival) 8456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 8466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v; 8476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG abs_ival; 8486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG t; /* unsigned so >> doesn't propagate sign bit */ 8496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int ndigits = 0; 8506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int negative = 0; 8516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ival < 0) { 8536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* avoid signed overflow on negation; see comments 8546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm in PyLong_FromLong above. */ 8556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm abs_ival = (unsigned PY_LONG_LONG)(-1-ival) + 1; 8566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negative = 1; 8576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 8596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm abs_ival = (unsigned PY_LONG_LONG)ival; 8606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Count the number of Python digits. 8636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm We used to pick 5 ("big enough for anything"), but that's a 8646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm waste of time and space given that 5*15 = 75 bits are rarely 8656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm needed. */ 8666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = abs_ival; 8676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 8686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++ndigits; 8696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 8706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndigits); 8726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v != NULL) { 8736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *p = v->ob_digit; 8746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = negative ? -ndigits : ndigits; 8756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = abs_ival; 8766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 8776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p++ = (digit)(t & PyLong_MASK); 8786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 8796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)v; 8826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 8836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C unsigned PY_LONG_LONG int. */ 8856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 8876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival) 8886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 8896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v; 8906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG t; 8916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int ndigits = 0; 8926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 8936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Count the number of Python digits. */ 8946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t = (unsigned PY_LONG_LONG)ival; 8956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (t) { 8966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++ndigits; 8976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t >>= PyLong_SHIFT; 8986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 8996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(ndigits); 9006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v != NULL) { 9016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *p = v->ob_digit; 9026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(v) = ndigits; 9036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (ival) { 9046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p++ = (digit)(ival & PyLong_MASK); 9056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ival >>= PyLong_SHIFT; 9066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)v; 9096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 9106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C Py_ssize_t. */ 9126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 9146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromSsize_t(Py_ssize_t ival) 9156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 9166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t bytes = ival; 9176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int one = 1; 9186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_FromByteArray((unsigned char *)&bytes, 9196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1); 9206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 9216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Create a new long int object from a C size_t. */ 9236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 9256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromSize_t(size_t ival) 9266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 9276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_t bytes = ival; 9286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int one = 1; 9296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_FromByteArray((unsigned char *)&bytes, 9306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); 9316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 9326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C PY_LONG_LONG int from a long int object. 9346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Return -1 and set an error if overflow occurs. */ 9356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPY_LONG_LONG 9376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsLongLong(PyObject *vv) 9386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 9396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PY_LONG_LONG bytes; 9406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int one = 1; 9416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int res; 9426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL) { 9446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 9456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 9466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyLong_Check(vv)) { 9486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyNumberMethods *nb; 9496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *io; 9506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(vv)) 9516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PY_LONG_LONG)PyInt_AsLong(vv); 9526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((nb = vv->ob_type->tp_as_number) == NULL || 9536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nb->nb_int == NULL) { 9546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, "an integer is required"); 9556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 9566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm io = (*nb->nb_int) (vv); 9586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (io == NULL) 9596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 9606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(io)) { 9616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bytes = PyInt_AsLong(io); 9626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(io); 9636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return bytes; 9646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_Check(io)) { 9666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bytes = PyLong_AsLongLong(io); 9676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(io); 9686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return bytes; 9696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(io); 9716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, "integer conversion failed"); 9726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 9736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 9766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1); 9776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 9796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (res < 0) 9806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PY_LONG_LONG)-1; 9816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 9826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return bytes; 9836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 9846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C unsigned PY_LONG_LONG int from a long int object. 9866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Return -1 and set an error if overflow occurs. */ 9876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmunsigned PY_LONG_LONG 9896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsUnsignedLongLong(PyObject *vv) 9906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 9916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG bytes; 9926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int one = 1; 9936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int res; 9946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 9956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL || !PyLong_Check(vv)) { 9966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 9976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned PY_LONG_LONG)-1; 9986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 9996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 10016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); 10026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 10046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (res < 0) 10056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned PY_LONG_LONG)res; 10066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 10076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return bytes; 10086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 10096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C unsigned long int from a long int object, ignoring the high bits. 10116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns -1 and sets an error condition if an error occurs. */ 10126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmunsigned PY_LONG_LONG 10146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsUnsignedLongLongMask(PyObject *vv) 10156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 10166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 10176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG x; 10186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 10196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 10206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL || !PyLong_Check(vv)) { 10226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 10236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (unsigned long) -1; 10246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 10266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = v->ob_size; 10276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 10286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 10296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 10306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 10316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -i; 10326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 10346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 10356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return x * sign; 10376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 10386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C long long int from a Python long or Python int object. 10406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm On overflow, returns -1 and sets *overflow to 1 or -1 depending 10416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm on the sign of the result. Otherwise *overflow is 0. 10426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm For other errors (e.g., type error), returns -1 and sets an error 10446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm condition. 10456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm*/ 10466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPY_LONG_LONG 10486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) 10496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 10506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* This version by Tim Peters */ 10516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *v; 10526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned PY_LONG_LONG x, prev; 10536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PY_LONG_LONG res; 10546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 10556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 10566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int do_decref = 0; /* if nb_int was called */ 10576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = 0; 10596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL) { 10606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 10616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 10626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(vv)) 10656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_AsLong(vv); 10666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyLong_Check(vv)) { 10686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyNumberMethods *nb; 10696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nb = vv->ob_type->tp_as_number; 10706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (nb == NULL || nb->nb_int == NULL) { 10716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, 10726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "an integer is required"); 10736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 10746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vv = (*nb->nb_int) (vv); 10766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (vv == NULL) 10776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 10786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do_decref = 1; 10796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if(PyInt_Check(vv)) { 10806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = PyInt_AsLong(vv); 10816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto exit; 10826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyLong_Check(vv)) { 10846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(vv); 10856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, 10866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "nb_int should return int object"); 10876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 10886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 10906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = -1; 10926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = (PyLongObject *)vv; 10936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = Py_SIZE(v); 10946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 10956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm switch (i) { 10966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case -1: 10976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = -(sdigit)v->ob_digit[0]; 10986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 10996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case 0: 11006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = 0; 11016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 11026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case 1: 11036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = v->ob_digit[0]; 11046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 11056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm default: 11066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 11076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 11086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 11096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 11106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -(i); 11116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 11136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm prev = x; 11146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x << PyLong_SHIFT) + v->ob_digit[i]; 11156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((x >> PyLong_SHIFT) != prev) { 11166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = sign; 11176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto exit; 11186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Haven't lost any bits, but casting to long requires extra 11216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * care (see comment above). 11226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 11236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x <= (unsigned PY_LONG_LONG)PY_LLONG_MAX) { 11246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = (PY_LONG_LONG)x * sign; 11256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (sign < 0 && x == PY_ABS_LLONG_MIN) { 11276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = PY_LLONG_MIN; 11286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 11306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *overflow = sign; 11316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* res is already set to -1 */ 11326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm exit: 11356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (do_decref) { 11366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(vv); 11376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return res; 11396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 11406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#undef IS_LITTLE_ENDIAN 11426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif /* HAVE_LONG_LONG */ 11446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 11476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmconvert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) { 11486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_Check(v)) { 11496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *a = (PyLongObject *) v; 11506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(v); 11516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyInt_Check(v)) { 11536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v)); 11546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 11566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 11576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_Check(w)) { 11596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *b = (PyLongObject *) w; 11606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(w); 11616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyInt_Check(w)) { 11636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w)); 11646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 11666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(*a); 11676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 11686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 1; 11706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 11716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define CONVERT_BINOP(v, w, a, b) \ 11736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { \ 11746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!convert_binop(v, w, a, b)) { \ 11756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(Py_NotImplemented); \ 11766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_NotImplemented; \ 11776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } \ 11786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while(0) \ 11796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d < 11816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2**k if d is nonzero, else 0. */ 11826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic const unsigned char BitLengthTable[32] = { 11846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 11856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 11866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 11876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 11886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 11896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbits_in_digit(digit d) 11906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 11916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int d_bits = 0; 11926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (d >= 32) { 11936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm d_bits += 6; 11946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm d >>= 6; 11956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 11966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm d_bits += (int)BitLengthTable[d]; 11976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return d_bits; 11986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 11996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * is modified in place, by adding y to it. Carries are propagated as far as 12026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * x[m-1], and the remaining carry (0 or 1) is returned. 12036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 12046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic digit 12056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmv_iadd(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 12076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 12086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry = 0; 12096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(m >= n); 12116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < n; ++i) { 12126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += x[i] + y[i]; 12136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x[i] = carry & PyLong_MASK; 12146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 12156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert((carry & 1) == carry); 12166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; carry && i < m; ++i) { 12186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += x[i]; 12196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x[i] = carry & PyLong_MASK; 12206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 12216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert((carry & 1) == carry); 12226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return carry; 12246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 12256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * is modified in place, by subtracting y from it. Borrows are propagated as 12286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * far as x[m-1], and the remaining borrow (0 or 1) is returned. 12296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 12306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic digit 12316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmv_isub(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 12336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 12346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit borrow = 0; 12356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(m >= n); 12376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < n; ++i) { 12386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow = x[i] - y[i] - borrow; 12396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x[i] = borrow & PyLong_MASK; 12406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow >>= PyLong_SHIFT; 12416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow &= 1; /* keep only 1 sign bit */ 12426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; borrow && i < m; ++i) { 12446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow = x[i] - borrow; 12456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x[i] = borrow & PyLong_MASK; 12466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow >>= PyLong_SHIFT; 12476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow &= 1; 12486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return borrow; 12506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 12516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Shift digit vector a[0:m] d bits left, with 0 <= d < PyLong_SHIFT. Put 12536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * result in z[0:m], and return the d bits shifted out of the top. 12546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 12556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic digit 12566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmv_lshift(digit *z, digit *a, Py_ssize_t m, int d) 12576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 12586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 12596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry = 0; 12606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(0 <= d && d < PyLong_SHIFT); 12626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i=0; i < m; i++) { 12636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits acc = (twodigits)a[i] << d | carry; 12646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z[i] = (digit)acc & PyLong_MASK; 12656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = (digit)(acc >> PyLong_SHIFT); 12666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return carry; 12686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 12696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Shift digit vector a[0:m] d bits right, with 0 <= d < PyLong_SHIFT. Put 12716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * result in z[0:m], and return the d bits shifted out of the bottom. 12726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 12736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic digit 12746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmv_rshift(digit *z, digit *a, Py_ssize_t m, int d) 12756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 12766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 12776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry = 0; 12786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit mask = ((digit)1 << d) - 1U; 12796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(0 <= d && d < PyLong_SHIFT); 12816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i=m; i-- > 0;) { 12826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits acc = (twodigits)carry << PyLong_SHIFT | a[i]; 12836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = (digit)acc & mask; 12846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z[i] = (digit)(acc >> d); 12856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 12866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return carry; 12876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 12886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Divide long pin, w/ size digits, by non-zero digit n, storing quotient 12906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm in pout, and returning the remainder. pin and pout point at the LSD. 12916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm It's OK for pin == pout on entry, which saves oodles of mallocs/frees in 12926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _PyLong_Format, but that should be done with great care since longs are 12936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm immutable. */ 12946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 12956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic digit 12966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylminplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n) 12976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 12986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits rem = 0; 12996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(n > 0 && n <= PyLong_MASK); 13016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pin += size; 13026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pout += size; 13036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--size >= 0) { 13046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit hi; 13056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = (rem << PyLong_SHIFT) | *--pin; 13066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--pout = hi = (digit)(rem / n); 13076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem -= (twodigits)hi * n; 13086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (digit)rem; 13106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 13116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Divide a long integer by a digit, returning both the quotient 13136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (as function result) and the remainder (through *prem). 13146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm The sign of a is ignored; n should not be zero. */ 13156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 13176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdivrem1(PyLongObject *a, digit n, digit *prem) 13186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 13196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const Py_ssize_t size = ABS(Py_SIZE(a)); 13206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 13216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(n > 0 && n <= PyLong_MASK); 13236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size); 13246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 13256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 13266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n); 13276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(z); 13286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 13296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Convert a long integer to a base 10 string. Returns a new non-shared 13316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm string. (Return value is non-shared so that callers can modify the 13326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm returned value if necessary.) */ 13336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 13356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_to_decimal_string(PyObject *aa, int addL) 13366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 13376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *scratch, *a; 13386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *str; 13396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size, strlen, size_a, i, j; 13406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pout, *pin, rem, tenpow; 13416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *p; 13426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int negative; 13436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a = (PyLongObject *)aa; 13456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == NULL || !PyLong_Check(a)) { 13466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 13476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 13486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = ABS(Py_SIZE(a)); 13506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negative = Py_SIZE(a) < 0; 13516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* quick and dirty upper bound for the number of digits 13536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm required to express a in base _PyLong_DECIMAL_BASE: 13546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm #digits = 1 + floor(log2(a) / log2(_PyLong_DECIMAL_BASE)) 13566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm But log2(a) < size_a * PyLong_SHIFT, and 13586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm log2(_PyLong_DECIMAL_BASE) = log2(10) * _PyLong_DECIMAL_SHIFT 13596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm > 3 * _PyLong_DECIMAL_SHIFT 13606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 13616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a > PY_SSIZE_T_MAX / PyLong_SHIFT) { 13626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 13636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long is too large to format"); 13646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 13656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* the expression size_a * PyLong_SHIFT is now safe from overflow */ 13676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size = 1 + size_a * PyLong_SHIFT / (3 * _PyLong_DECIMAL_SHIFT); 13686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm scratch = _PyLong_New(size); 13696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (scratch == NULL) 13706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 13716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* convert array of base _PyLong_BASE digits in pin to an array of 13736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base _PyLong_DECIMAL_BASE digits in pout, following Knuth (TAOCP, 13746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Volume 2 (3rd edn), section 4.4, Method 1b). */ 13756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pin = a->ob_digit; 13766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pout = scratch->ob_digit; 13776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size = 0; 13786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = size_a; --i >= 0; ) { 13796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit hi = pin[i]; 13806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (j = 0; j < size; j++) { 13816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits z = (twodigits)pout[j] << PyLong_SHIFT | hi; 13826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm hi = (digit)(z / _PyLong_DECIMAL_BASE); 13836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pout[j] = (digit)(z - (twodigits)hi * 13846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _PyLong_DECIMAL_BASE); 13856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (hi) { 13876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pout[size++] = hi % _PyLong_DECIMAL_BASE; 13886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm hi /= _PyLong_DECIMAL_BASE; 13896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* check for keyboard interrupt */ 13916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIGCHECK({ 13926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(scratch); 13936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 13946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm }); 13956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 13966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* pout should have at least one digit, so that the case when a = 0 13976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm works correctly */ 13986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size == 0) 13996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pout[size++] = 0; 14006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* calculate exact length of output string, and allocate */ 14026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm strlen = (addL != 0) + negative + 14036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1 + (size - 1) * _PyLong_DECIMAL_SHIFT; 14046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm tenpow = 10; 14056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = pout[size-1]; 14066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (rem >= tenpow) { 14076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm tenpow *= 10; 14086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm strlen++; 14096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str = PyString_FromStringAndSize(NULL, strlen); 14116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str == NULL) { 14126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(scratch); 14136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 14146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* fill the string right-to-left */ 14176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p = PyString_AS_STRING(str) + strlen; 14186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p = '\0'; 14196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (addL) 14206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = 'L'; 14216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* pout[0] through pout[size-2] contribute exactly 14226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _PyLong_DECIMAL_SHIFT digits each */ 14236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i=0; i < size - 1; i++) { 14246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = pout[i]; 14256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (j = 0; j < _PyLong_DECIMAL_SHIFT; j++) { 14266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0' + rem % 10; 14276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem /= 10; 14286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* pout[size-1]: always produce at least one decimal digit */ 14316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = pout[i]; 14326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 14336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0' + rem % 10; 14346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem /= 10; 14356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while (rem != 0); 14366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* and sign */ 14386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (negative) 14396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '-'; 14406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* check we've counted correctly */ 14426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(p == PyString_AS_STRING(str)); 14436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(scratch); 14446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)str; 14456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 14466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Convert the long to a string object with given base, 14486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm appending a base prefix of 0[box] if base is 2, 8 or 16. 14496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Add a trailing "L" if addL is non-zero. 14506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm If newstyle is zero, then use the pre-2.6 behavior of octal having 14516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a leading "0", instead of the prefix "0o" */ 14526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyAPI_FUNC(PyObject *) 14536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_Format(PyObject *aa, int base, int addL, int newstyle) 14546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 14556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register PyLongObject *a = (PyLongObject *)aa; 14566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyStringObject *str; 14576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i, sz; 14586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a; 14596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *p; 14606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int bits; 14616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char sign = '\0'; 14626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (base == 10) 14646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_to_decimal_string((PyObject *)a, addL); 14656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == NULL || !PyLong_Check(a)) { 14676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 14686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 14696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(base >= 2 && base <= 36); 14716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = ABS(Py_SIZE(a)); 14726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Compute a rough upper bound for the length of the string */ 14746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = base; 14756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits = 0; 14766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (i > 1) { 14776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++bits; 14786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i >>= 1; 14796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = 5 + (addL ? 1 : 0); 14816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* ensure we don't get signed overflow in sz calculation */ 14826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a > (PY_SSIZE_T_MAX - i) / PyLong_SHIFT) { 14836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 14846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long is too large to format"); 14856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 14866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 14876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sz = i + 1 + (size_a * PyLong_SHIFT - 1) / bits; 14886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(sz >= 0); 14896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz); 14906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str == NULL) 14916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 14926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm p = PyString_AS_STRING(str) + sz; 14936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *p = '\0'; 14946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (addL) 14956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = 'L'; 14966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size < 0) 14976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = '-'; 14986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 14996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size == 0) { 15006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0'; 15016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if ((base & (base - 1)) == 0) { 15036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* JRH: special case for power-of-2 bases */ 15046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits accum = 0; 15056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int accumbits = 0; /* # of bits in accum */ 15066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int basebits = 1; /* # of bits in base-1 */ 15076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = base; 15086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while ((i >>= 1) > 1) 15096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++basebits; 15106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 15116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_a; ++i) { 15126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (twodigits)a->ob_digit[i] << accumbits; 15136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits += PyLong_SHIFT; 15146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(accumbits >= basebits); 15156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 15166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char cdigit = (char)(accum & (base - 1)); 15176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm cdigit += (cdigit < 10) ? '0' : 'a'-10; 15186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(p > PyString_AS_STRING(str)); 15196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = cdigit; 15206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accumbits -= basebits; 15216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum >>= basebits; 15226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while (i < size_a-1 ? accumbits >= basebits : accum > 0); 15236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 15266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Not 0, and base not a power of 2. Divide repeatedly by 15276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base, but for speed use the highest power of base that 15286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm fits in a digit. */ 15296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size = size_a; 15306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pin = a->ob_digit; 15316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *scratch; 15326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* powbasw <- largest power of base that fits in a digit. */ 15336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit powbase = base; /* powbase == base ** power */ 15346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int power = 1; 15356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (;;) { 15366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits newpow = powbase * (twodigits)base; 15376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (newpow >> PyLong_SHIFT) 15386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* doesn't fit in a digit */ 15396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 15406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm powbase = (digit)newpow; 15416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++power; 15426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 15446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Get a scratch area for repeated division. */ 15456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm scratch = _PyLong_New(size); 15466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (scratch == NULL) { 15476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(str); 15486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 15496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 15516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Repeatedly divide by powbase. */ 15526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 15536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int ntostore = power; 15546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem = inplace_divrem1(scratch->ob_digit, 15556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pin, size, powbase); 15566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pin = scratch->ob_digit; /* no need to use a again */ 15576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (pin[size - 1] == 0) 15586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm --size; 15596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIGCHECK({ 15606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(scratch); 15616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(str); 15626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 15636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm }); 15646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 15656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Break rem into digits. */ 15666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(ntostore > 0); 15676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 15686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit nextrem = (digit)(rem / base); 15696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char c = (char)(rem - nextrem * base); 15706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(p > PyString_AS_STRING(str)); 15716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c += (c < 10) ? '0' : 'a'-10; 15726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = c; 15736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = nextrem; 15746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm --ntostore; 15756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Termination is a bit delicate: must not 15766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm store leading zeroes, so must get out if 15776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm remaining quotient and rem are both 0. */ 15786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while (ntostore && (size || rem)); 15796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while (size != 0); 15806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(scratch); 15816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 15836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (base == 2) { 15846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = 'b'; 15856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0'; 15866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (base == 8) { 15886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (newstyle) { 15896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = 'o'; 15906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0'; 15916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 15936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a != 0) 15946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0'; 15956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 15966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (base == 16) { 15976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = 'x'; 15986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0'; 15996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 16006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (base != 10) { 16016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '#'; 16026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0' + base%10; 16036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (base > 10) 16046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = '0' + base/10; 16056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 16066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (sign) 16076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--p = sign; 16086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (p != PyString_AS_STRING(str)) { 16096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *q = PyString_AS_STRING(str); 16106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(p > q); 16116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { 16126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while ((*q++ = *p++) != '\0'); 16136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm q--; 16146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _PyString_Resize((PyObject **)&str, 16156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (Py_ssize_t) (q - PyString_AS_STRING(str))); 16166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 16176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)str; 16186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 16196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 16206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Table of digit values for 8-bit string -> integer conversion. 16216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * '0' maps to 0, ..., '9' maps to 9. 16226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35. 16236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * All other indices map to 37. 16246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * Note that when converting a base B string, a char c is a legitimate 16256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B. 16266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 16276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmint _PyLong_DigitValue[256] = { 16286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 37, 37, 37, 37, 37, 37, 16326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 16456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 16466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* *str points to the first digit in a string of base `base` digits. base 16476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first 16486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * non-digit (which may be *str!). A normalized long is returned. 16496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * The point to this routine is that it takes time linear in the number of 16506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * string characters. 16516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 16526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 16536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_from_binary_base(char **str, int base) 16546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 16556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *p = *str; 16566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *start = p; 16576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int bits_per_char; 16586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t n; 16596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 16606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits accum; 16616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int bits_in_accum; 16626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pdigit; 16636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 16646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0); 16656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n = base; 16666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (bits_per_char = -1; n; ++bits_per_char) 16676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n >>= 1; 16686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* n <- total # of bits needed, while setting p to end-of-string */ 16696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base) 16706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++p; 16716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *str = p; 16726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */ 16736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n = (p - start) * bits_per_char + PyLong_SHIFT - 1; 16746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (n / bits_per_char < p - start) { 16756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, 16766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long string too large to convert"); 16776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 16786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 16796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n = n / PyLong_SHIFT; 16806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(n); 16816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 16826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 16836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Read string from right, and fill in long from left; i.e., 16846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * from least to most significant in both. 16856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 16866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum = 0; 16876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits_in_accum = 0; 16886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pdigit = z->ob_digit; 16896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--p >= start) { 16906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int k = _PyLong_DigitValue[Py_CHARMASK(*p)]; 16916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(k >= 0 && k < base); 16926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (twodigits)k << bits_in_accum; 16936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits_in_accum += bits_per_char; 16946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (bits_in_accum >= PyLong_SHIFT) { 16956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdigit++ = (digit)(accum & PyLong_MASK); 16966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(pdigit - z->ob_digit <= n); 16976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum >>= PyLong_SHIFT; 16986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits_in_accum -= PyLong_SHIFT; 16996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(bits_in_accum < PyLong_SHIFT); 17006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (bits_in_accum) { 17036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(bits_in_accum <= PyLong_SHIFT); 17046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdigit++ = (digit)accum; 17056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(pdigit - z->ob_digit <= n); 17066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (pdigit - z->ob_digit < n) 17086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdigit++ = 0; 17096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(z); 17106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 17116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 17136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromString(char *str, char **pend, int base) 17146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 17156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign = 1; 17166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *start, *orig_str = str; 17176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 17186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *strobj, *strrepr; 17196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t slen; 17206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((base != 0 && base < 2) || base > 36) { 17226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, 17236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long() arg 2 must be >= 2 and <= 36"); 17246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 17256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str++; 17286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*str == '+') 17296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++str; 17306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (*str == '-') { 17316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++str; 17326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 17336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str++; 17366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (base == 0) { 17376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* No base given. Deduce the base from the contents 17386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm of the string */ 17396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str[0] != '0') 17406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = 10; 17416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (str[1] == 'x' || str[1] == 'X') 17426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = 16; 17436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (str[1] == 'o' || str[1] == 'O') 17446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = 8; 17456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (str[1] == 'b' || str[1] == 'B') 17466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = 2; 17476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 17486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* "old" (C-style) octal literal, still valid in 17496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2.x, although illegal in 3.x */ 17506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = 8; 17516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 17526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Whether or not we were deducing the base, skip leading chars 17536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm as needed */ 17546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str[0] == '0' && 17556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ((base == 16 && (str[1] == 'x' || str[1] == 'X')) || 17566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (base == 8 && (str[1] == 'o' || str[1] == 'O')) || 17576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (base == 2 && (str[1] == 'b' || str[1] == 'B')))) 17586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str += 2; 17596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm start = str; 17616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((base & (base - 1)) == 0) 17626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = long_from_binary_base(&str, base); 17636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 17646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/*** 17656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmBinary bases can be converted in time linear in the number of digits, because 17666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPython's representation base is binary. Other bases (including decimal!) use 17676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthe simple quadratic-time algorithm below, complicated by some speed tricks. 17686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmFirst some math: the largest integer that can be expressed in N base-B digits 17706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmis B**N-1. Consequently, if we have an N-digit input in base B, the worst- 17716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmcase number of Python digits needed to hold it is the smallest integer n s.t. 17726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLong_BASE**n-1 >= B**N-1 [or, adding 1 to both sides] 17746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLong_BASE**n >= B**N [taking logs to base PyLong_BASE] 17756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n >= log(B**N)/log(PyLong_BASE) = N * log(B)/log(PyLong_BASE) 17766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThe static array log_base_PyLong_BASE[base] == log(base)/log(PyLong_BASE) so 17786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmwe can compute this quickly. A Python long with that much space is reserved 17796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmnear the start, and the result is computed into it. 17806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThe input string is actually treated as being in base base**i (i.e., i digits 17826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmare processed at a time), where two more static arrays hold: 17836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convwidth_base[base] = the largest integer i such that 17856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base**i <= PyLong_BASE 17866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmultmax_base[base] = base ** convwidth_base[base] 17876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThe first of these is the largest i such that i consecutive input digits 17896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmmust fit in a single Python digit. The second is effectively the input 17906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbase we're really using. 17916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmViewing the input as a sequence <c0, c1, ..., c_n-1> of digits in base 17936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmconvmultmax_base[base], the result is "simply" 17946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (((c0*B + c1)*B + c2)*B + c3)*B + ... ))) + c_n-1 17966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmwhere B = convmultmax_base[base]. 17986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 17996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmError analysis: as above, the number of Python digits `n` needed is worst- 18006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmcase 18016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n >= N * log(B)/log(PyLong_BASE) 18036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmwhere `N` is the number of input digits in base `B`. This is computed via 18056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 18076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbelow. Two numeric concerns are how much space this can waste, and whether 18096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthe computed result can be too small. To be concrete, assume PyLong_BASE = 18106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm2**15, which is the default (and it's unlikely anyone changes that). 18116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmWaste isn't a problem: provided the first input digit isn't 0, the difference 18136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbetween the worst-case input with N digits and the smallest input with N 18146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdigits is about a factor of B, but B is small compared to PyLong_BASE so at 18156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmmost one allocated Python digit can remain unused on that count. If 18166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmN*log(B)/log(PyLong_BASE) is mathematically an exact integer, then truncating 18176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthat and adding 1 returns a result 1 larger than necessary. However, that 18186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmcan't happen: whenever B is a power of 2, long_from_binary_base() is called 18196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylminstead, and it's impossible for B**i to be an integer power of 2**15 when B 18206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmis not a power of 2 (i.e., it's impossible for N*log(B)/log(PyLong_BASE) to be 18216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylman exact integer when B is not a power of 2, since B**i has a prime factor 18226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmother than 2 in that case, but (2**15)**j's only prime factor is 2). 18236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThe computed result can be too small if the true value of 18256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmN*log(B)/log(PyLong_BASE) is a little bit larger than an exact integer, but 18266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdue to roundoff errors (in computing log(B), log(PyLong_BASE), their quotient, 18276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmand/or multiplying that by N) yields a numeric result a little less than that 18286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylminteger. Unfortunately, "how close can a transcendental function get to an 18296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylminteger over some range?" questions are generally theoretically intractable. 18306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmComputer analysis via continued fractions is practical: expand 18316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlog(B)/log(PyLong_BASE) via continued fractions, giving a sequence i/j of "the 18326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbest" rational approximations. Then j*log(B)/log(PyLong_BASE) is 18336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmapproximately equal to (the integer) i. This shows that we can get very close 18346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmto being in trouble, but very rarely. For example, 76573 is a denominator in 18356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmone of the continued-fraction approximations to log(10)/log(2**15), and 18366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmindeed: 18376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm >>> log(10)/log(2**15)*76573 18396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 16958.000000654003 18406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmis very close to an integer. If we were working with IEEE single-precision, 18426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmrounding errors could kill us. Finding worst cases in IEEE double-precision 18436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmrequires better-than-double-precision log() functions, and Tim didn't bother. 18446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmInstead the code checks to see whether the allocated space is enough as each 18456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmnew Python digit is added, and copies the whole thing to a larger long if not. 18466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThis should happen extremely rarely, and in fact I don't have a test case 18476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthat triggers it(!). Instead the code was tested by artificially allocating 18486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmjust 1 digit at the start, so that the copying code was exercised for every 18496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdigit beyond the first. 18506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm***/ 18516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm register twodigits c; /* current input character */ 18526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_z; 18536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int i; 18546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int convwidth; 18556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits convmultmax, convmult; 18566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pz, *pzstop; 18576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char* scan; 18586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm static double log_base_PyLong_BASE[37] = {0.0e0,}; 18606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm static int convwidth_base[37] = {0,}; 18616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm static twodigits convmultmax_base[37] = {0,}; 18626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (log_base_PyLong_BASE[base] == 0.0) { 18646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits convmax = base; 18656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int i = 1; 18666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm log_base_PyLong_BASE[base] = (log((double)base) / 18686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm log((double)PyLong_BASE)); 18696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (;;) { 18706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits next = convmax * base; 18716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (next > PyLong_BASE) 18726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 18736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmax = next; 18746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++i; 18756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 18766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmultmax_base[base] = convmax; 18776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(i > 0); 18786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convwidth_base[base] = i; 18796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 18806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Find length of the string of numeric characters. */ 18826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm scan = str; 18836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base) 18846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++scan; 18856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 18866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Create a long object that can contain the largest possible 18876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * integer with this base and length. Note that there's no 18886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * need to initialize z->ob_digit -- no slot is read up before 18896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * being stored into. 18906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 18916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 18926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Uncomment next line to test exceedingly rare copy code */ 18936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* size_z = 1; */ 18946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(size_z > 0); 18956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_z); 18966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 18976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 18986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(z) = 0; 18996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* `convwidth` consecutive input digits are treated as a single 19016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * digit in base `convmultmax`. 19026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 19036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convwidth = convwidth_base[base]; 19046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmultmax = convmultmax_base[base]; 19056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Work ;-) */ 19076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (str < scan) { 19086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* grab up to convwidth digits from the input string */ 19096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = (digit)_PyLong_DigitValue[Py_CHARMASK(*str++)]; 19106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 1; i < convwidth && str != scan; ++i, ++str) { 19116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = (twodigits)(c * base + 19126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm _PyLong_DigitValue[Py_CHARMASK(*str)]); 19136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(c < PyLong_BASE); 19146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmult = convmultmax; 19176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Calculate the shift only if we couldn't get 19186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * convwidth digits. 19196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 19206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i != convwidth) { 19216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmult = base; 19226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for ( ; i > 1; --i) 19236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm convmult *= base; 19246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Multiply z by convmult, and add c. */ 19276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pz = z->ob_digit; 19286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm pzstop = pz + Py_SIZE(z); 19296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; pz < pzstop; ++pz) { 19306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c += (twodigits)*pz * convmult; 19316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz = (digit)(c & PyLong_MASK); 19326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c >>= PyLong_SHIFT; 19336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* carry off the current end? */ 19356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (c) { 19366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(c < PyLong_BASE); 19376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(z) < size_z) { 19386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz = (digit)c; 19396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++Py_SIZE(z); 19406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 19426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *tmp; 19436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Extremely rare. Get more space. */ 19446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(z) == size_z); 19456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm tmp = _PyLong_New(size_z + 1); 19466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (tmp == NULL) { 19476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 19486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 19496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(tmp->ob_digit, 19516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit, 19526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sizeof(digit) * size_z); 19536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 19546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = tmp; 19556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[size_z] = (digit)c; 19566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++size_z; 19576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 19616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 19626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 19636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str == start) 19646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto onError; 19656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (sign < 0) 19666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(z) = -(Py_SIZE(z)); 19676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*str == 'L' || *str == 'l') 19686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str++; 19696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (*str && isspace(Py_CHARMASK(*str))) 19706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm str++; 19716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*str != '\0') 19726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto onError; 19736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (pend) 19746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pend = str; 19756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *) z; 19766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm onError: 19786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(z); 19796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200; 19806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm strobj = PyString_FromStringAndSize(orig_str, slen); 19816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (strobj == NULL) 19826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 19836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm strrepr = PyObject_Repr(strobj); 19846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(strobj); 19856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (strrepr == NULL) 19866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 19876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_Format(PyExc_ValueError, 19886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "invalid literal for long() with base %d: %s", 19896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base, PyString_AS_STRING(strrepr)); 19906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(strrepr); 19916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 19926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 19936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 19946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifdef Py_USING_UNICODE 19956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 19966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base) 19976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 19986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *result; 19996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *buffer = (char *)PyMem_MALLOC(length+1); 20006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (buffer == NULL) 20026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 20036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) { 20056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyMem_FREE(buffer); 20066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 20076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = PyLong_FromString(buffer, NULL, base); 20096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyMem_FREE(buffer); 20106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return result; 20116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 20126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 20136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* forward */ 20156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject *x_divrem 20166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (PyLongObject *, PyLongObject *, PyLongObject **); 20176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject *long_long(PyObject *v); 20186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Long division with remainder, top-level routine */ 20206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 20226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_divrem(PyLongObject *a, PyLongObject *b, 20236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject **pdiv, PyLongObject **prem) 20246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 20256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 20266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 20276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_b == 0) { 20296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ZeroDivisionError, 20306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long division or modulo by zero"); 20316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 20326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a < size_b || 20346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (size_a == size_b && 20356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) { 20366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* |a| < |b|. */ 20376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdiv = _PyLong_New(0); 20386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*pdiv == NULL) 20396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 20406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(a); 20416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = (PyLongObject *) a; 20426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 20436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_b == 1) { 20456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem = 0; 20466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = divrem1(a, b->ob_digit[0], &rem); 20476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 20486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 20496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = (PyLongObject *) PyLong_FromLong((long)rem); 20506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*prem == NULL) { 20516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 20526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 20536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 20566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_divrem(a, b, prem); 20576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 20586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 20596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 20606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Set the signs. 20616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm The quotient z has the sign of a*b; 20626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the remainder r has the sign of a, 20636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm so a = b*z + r. */ 20646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((a->ob_size < 0) != (b->ob_size < 0)) 20656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 20666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size < 0 && (*prem)->ob_size != 0) 20676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (*prem)->ob_size = -((*prem)->ob_size); 20686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdiv = z; 20696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 20706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 20716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Unsigned long division with remainder -- the algorithm. The arguments v1 20736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */ 20746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 20766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmx_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) 20776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 20786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *v, *w, *a; 20796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i, k, size_v, size_w; 20806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int d; 20816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit wm1, wm2, carry, q, r, vtop, *v0, *vk, *w0, *ak; 20826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits vv; 20836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sdigit zhi; 20846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm stwodigits z; 20856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* We follow Knuth [The Art of Computer Programming, Vol. 2 (3rd 20876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm edn.), section 4.3.1, Algorithm D], except that we don't explicitly 20886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm handle the special case when the initial estimate q for a quotient 20896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit is >= PyLong_BASE: the max value for q is PyLong_BASE+1, and 20906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm that won't overflow a digit. */ 20916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 20926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* allocate space; w will also be used to hold the final remainder */ 20936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_v = ABS(Py_SIZE(v1)); 20946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_w = ABS(Py_SIZE(w1)); 20956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */ 20966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_New(size_v+1); 20976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v == NULL) { 20986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = NULL; 20996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 21006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm w = _PyLong_New(size_w); 21026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (w == NULL) { 21036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(v); 21046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = NULL; 21056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 21066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* normalize: shift w1 left so that its top digit is >= PyLong_BASE/2. 21096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift v1 left by the same amount. Results go into w and v. */ 21106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm d = PyLong_SHIFT - bits_in_digit(w1->ob_digit[size_w-1]); 21116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = v_lshift(w->ob_digit, w1->ob_digit, size_w, d); 21126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry == 0); 21136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = v_lshift(v->ob_digit, v1->ob_digit, size_v, d); 21146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (carry != 0 || v->ob_digit[size_v-1] >= w->ob_digit[size_w-1]) { 21156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v->ob_digit[size_v] = carry; 21166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_v++; 21176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Now v->ob_digit[size_v-1] < w->ob_digit[size_w-1], so quotient has 21206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm at most (and usually exactly) k = size_v - size_w digits. */ 21216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm k = size_v - size_w; 21226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(k >= 0); 21236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a = _PyLong_New(k); 21246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == NULL) { 21256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(w); 21266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(v); 21276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = NULL; 21286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 21296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v0 = v->ob_digit; 21316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm w0 = w->ob_digit; 21326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm wm1 = w0[size_w-1]; 21336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm wm2 = w0[size_w-2]; 21346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (vk = v0+k, ak = a->ob_digit + k; vk-- > v0;) { 21356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* inner loop: divide vk[0:size_w+1] by w0[0:size_w], giving 21366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm single-digit quotient q, remainder in vk[0:size_w]. */ 21376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIGCHECK({ 21396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 21406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(w); 21416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(v); 21426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = NULL; 21436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 21446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm }); 21456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* estimate quotient digit q; may overestimate by 1 (rare) */ 21476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vtop = vk[size_w]; 21486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(vtop <= wm1); 21496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vv = ((twodigits)vtop << PyLong_SHIFT) | vk[size_w-1]; 21506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm q = (digit)(vv / wm1); 21516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm r = (digit)(vv - (twodigits)wm1 * q); /* r = vv % wm1 */ 21526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while ((twodigits)wm2 * q > (((twodigits)r << PyLong_SHIFT) 21536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm | vk[size_w-2])) { 21546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm --q; 21556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm r += wm1; 21566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (r >= PyLong_BASE) 21576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 21586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(q <= PyLong_BASE); 21606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* subtract q*w0[0:size_w] from vk[0:size_w+1] */ 21626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm zhi = 0; 21636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_w; ++i) { 21646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* invariants: -PyLong_BASE <= -q <= zhi <= 0; 21656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm -PyLong_BASE * q <= z < PyLong_BASE */ 21666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = (sdigit)vk[i] + zhi - 21676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (stwodigits)q * (stwodigits)w0[i]; 21686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vk[i] = (digit)z & PyLong_MASK; 21696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm zhi = (sdigit)Py_ARITHMETIC_RIGHT_SHIFT(stwodigits, 21706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z, PyLong_SHIFT); 21716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* add w back if q was too large (this branch taken rarely) */ 21746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert((sdigit)vtop + zhi == -1 || (sdigit)vtop + zhi == 0); 21756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((sdigit)vtop + zhi < 0) { 21766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = 0; 21776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_w; ++i) { 21786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += vk[i] + w0[i]; 21796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm vk[i] = carry & PyLong_MASK; 21806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 21816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm --q; 21836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* store quotient digit */ 21866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(q < PyLong_BASE); 21876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *--ak = q; 21886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 21896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* unshift remainder; we reuse w to store the result */ 21916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = v_rshift(w0, v0, size_w, d); 21926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry==0); 21936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(v); 21946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *prem = long_normalize(w); 21966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(a); 21976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 21986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 21996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* For a nonzero PyLong a, express a in the form x * 2**e, with 0.5 <= 22006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm abs(x) < 1.0 and e >= 0; return x and put e in *e. Here x is 22016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rounded to DBL_MANT_DIG significant bits using round-half-to-even. 22026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm If a == 0, return 0.0 and set *e = 0. If the resulting exponent 22036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm e is larger than PY_SSIZE_T_MAX, raise OverflowError and return 22046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm -1.0. */ 22056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* attempt to define 2.0**DBL_MANT_DIG as a compile-time constant */ 22076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if DBL_MANT_DIG == 53 22086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define EXP2_DBL_MANT_DIG 9007199254740992.0 22096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#else 22106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define EXP2_DBL_MANT_DIG (ldexp(1.0, DBL_MANT_DIG)) 22116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 22126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdouble 22146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) 22156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 22166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t a_size, a_bits, shift_digits, shift_bits, x_size; 22176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* See below for why x_digits is always large enough. */ 22186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem, x_digits[2 + (DBL_MANT_DIG + 1) / PyLong_SHIFT]; 22196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double dx; 22206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Correction term for round-half-to-even rounding. For a digit x, 22216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "x + half_even_correction[x & 7]" gives x rounded to the nearest 22226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm multiple of 4, rounding ties to a multiple of 8. */ 22236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1}; 22246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size = ABS(Py_SIZE(a)); 22266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_size == 0) { 22276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Special case for 0: significand 0.0, exponent 0. */ 22286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *e = 0; 22296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0.0; 22306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 22316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_bits = bits_in_digit(a->ob_digit[a_size-1]); 22326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The following is an overflow-free version of the check 22336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "if ((a_size - 1) * PyLong_SHIFT + a_bits > PY_SSIZE_T_MAX) ..." */ 22346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_size >= (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 && 22356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (a_size > (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 || 22366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_bits > (PY_SSIZE_T_MAX - 1) % PyLong_SHIFT + 1)) 22376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 22386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_bits = (a_size - 1) * PyLong_SHIFT + a_bits; 22396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Shift the first DBL_MANT_DIG + 2 bits of a into x_digits[0:x_size] 22416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (shifting left if a_bits <= DBL_MANT_DIG + 2). 22426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Number of digits needed for result: write // for floor division. 22446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Then if shifting left, we end up using 22456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1 + a_size + (DBL_MANT_DIG + 2 - a_bits) // PyLong_SHIFT 22476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digits. If shifting right, we use 22496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size - (a_bits - DBL_MANT_DIG - 2) // PyLong_SHIFT 22516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digits. Using a_size = 1 + (a_bits - 1) // PyLong_SHIFT along with 22536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the inequalities 22546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm m // PyLong_SHIFT + n // PyLong_SHIFT <= (m + n) // PyLong_SHIFT 22566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm m // PyLong_SHIFT - n // PyLong_SHIFT <= 22576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1 + (m - n - 1) // PyLong_SHIFT, 22586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm valid for any integers m and n, we find that x_size satisfies 22606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size <= 2 + (DBL_MANT_DIG + 1) // PyLong_SHIFT 22626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm in both cases. 22646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 22656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_bits <= DBL_MANT_DIG + 2) { 22666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift_digits = (DBL_MANT_DIG + 2 - a_bits) / PyLong_SHIFT; 22676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift_bits = (DBL_MANT_DIG + 2 - a_bits) % PyLong_SHIFT; 22686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size = 0; 22696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (x_size < shift_digits) 22706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_digits[x_size++] = 0; 22716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = v_lshift(x_digits + x_size, a->ob_digit, a_size, 22726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (int)shift_bits); 22736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size += a_size; 22746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_digits[x_size++] = rem; 22756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 22766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 22776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift_digits = (a_bits - DBL_MANT_DIG - 2) / PyLong_SHIFT; 22786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift_bits = (a_bits - DBL_MANT_DIG - 2) % PyLong_SHIFT; 22796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = v_rshift(x_digits, a->ob_digit + shift_digits, 22806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size - shift_digits, (int)shift_bits); 22816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size = a_size - shift_digits; 22826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* For correct rounding below, we need the least significant 22836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bit of x to be 'sticky' for this shift: if any of the bits 22846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shifted out was nonzero, we set the least significant bit 22856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm of x. */ 22866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (rem) 22876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_digits[0] |= 1; 22886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 22896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (shift_digits > 0) 22906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_digit[--shift_digits]) { 22916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_digits[0] |= 1; 22926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 22936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 22946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 22956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(1 <= x_size && 22966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size <= (Py_ssize_t)(sizeof(x_digits)/sizeof(digit))); 22976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 22986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Round, and convert to double. */ 22996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_digits[0] += half_even_correction[x_digits[0] & 7]; 23006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx = x_digits[--x_size]; 23016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (x_size > 0) 23026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx = dx * PyLong_BASE + x_digits[--x_size]; 23036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Rescale; make correction if result is 1.0. */ 23056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx /= 4.0 * EXP2_DBL_MANT_DIG; 23066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (dx == 1.0) { 23076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_bits == PY_SSIZE_T_MAX) 23086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 23096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx = 0.5; 23106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_bits += 1; 23116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *e = a_bits; 23146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_SIZE(a) < 0 ? -dx : dx; 23156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm overflow: 23176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* exponent > PY_SSIZE_T_MAX */ 23186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 23196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "huge integer: number of bits overflows a Py_ssize_t"); 23206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *e = 0; 23216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1.0; 23226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Get a C double from a long int object. Rounds to the nearest double, 23256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm using the round-half-to-even rule in the case of a tie. */ 23266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdouble 23286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_AsDouble(PyObject *v) 23296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t exponent; 23316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double x; 23326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v == NULL || !PyLong_Check(v)) { 23346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadInternalCall(); 23356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1.0; 23366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = _PyLong_Frexp((PyLongObject *)v, &exponent); 23386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) { 23396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 23406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long int too large to convert to float"); 23416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1.0; 23426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return ldexp(x, (int)exponent); 23446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Methods */ 23476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic void 23496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_dealloc(PyObject *v) 23506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_TYPE(v)->tp_free(v); 23526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 23556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_repr(PyObject *v) 23566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_Format(v, 10, 1, 0); 23586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 23616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_str(PyObject *v) 23626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_Format(v, 10, 0, 0); 23646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 23676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_compare(PyLongObject *a, PyLongObject *b) 23686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t sign; 23706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(a) != Py_SIZE(b)) { 23726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = Py_SIZE(a) - Py_SIZE(b); 23736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 23756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i = ABS(Py_SIZE(a)); 23766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 23776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ; 23786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) 23796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 0; 23806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 23816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = (sdigit)a->ob_digit[i] - (sdigit)b->ob_digit[i]; 23826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(a) < 0) 23836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -sign; 23846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 23866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return sign < 0 ? -1 : sign > 0 ? 1 : 0; 23876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 23886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic long 23906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_hash(PyLongObject *v) 23916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 23926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm unsigned long x; 23936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 23946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign; 23956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 23966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* This is designed so that Python ints and longs with the 23976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm same value hash to the same value, otherwise comparisons 23986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm of mapping keys will turn out weird */ 23996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = v->ob_size; 24006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = 1; 24016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = 0; 24026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) { 24036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 24046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = -(i); 24056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The following loop produces a C unsigned long x such that x is 24076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm congruent to the absolute value of v modulo ULONG_MAX. The 24086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm resulting x is nonzero if and only if v is. */ 24096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0) { 24106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Force a native long #-bits (32 or 64) circular shift */ 24116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (x >> (8*SIZEOF_LONG-PyLong_SHIFT)) | (x << PyLong_SHIFT); 24126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x += v->ob_digit[i]; 24136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* If the addition above overflowed we compensate by 24146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm incrementing. This preserves the value modulo 24156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ULONG_MAX. */ 24166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x < v->ob_digit[i]) 24176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x++; 24186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = x * sign; 24206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == (unsigned long)-1) 24216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (unsigned long)-2; 24226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (long)x; 24236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 24246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Add the absolute values of two long integers. */ 24276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 24296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmx_add(PyLongObject *a, PyLongObject *b) 24306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 24316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 24336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 24346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry = 0; 24356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Ensure a is the larger of the two: */ 24376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a < size_b) { 24386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { PyLongObject *temp = a; a = b; b = temp; } 24396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { Py_ssize_t size_temp = size_a; 24406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = size_b; 24416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_b = size_temp; } 24426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_a+1); 24446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 24456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 24466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_b; ++i) { 24476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += a->ob_digit[i] + b->ob_digit[i]; 24486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = carry & PyLong_MASK; 24496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 24506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; i < size_a; ++i) { 24526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += a->ob_digit[i]; 24536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = carry & PyLong_MASK; 24546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 24556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = carry; 24576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(z); 24586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 24596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Subtract the absolute values of two integers. */ 24616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 24636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmx_sub(PyLongObject *a, PyLongObject *b) 24646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 24656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 24676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 24686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int sign = 1; 24696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit borrow = 0; 24706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 24716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Ensure a is the larger of the two: */ 24726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a < size_b) { 24736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 24746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { PyLongObject *temp = a; a = b; b = temp; } 24756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { Py_ssize_t size_temp = size_a; 24766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = size_b; 24776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_b = size_temp; } 24786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (size_a == size_b) { 24806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Find highest digit where a and b differ: */ 24816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = size_a; 24826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 24836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ; 24846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i < 0) 24856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_New(0); 24866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_digit[i] < b->ob_digit[i]) { 24876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sign = -1; 24886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm { PyLongObject *temp = a; a = b; b = temp; } 24896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = size_b = i+1; 24916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 24926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_a); 24936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 24946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 24956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_b; ++i) { 24966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The following assumes unsigned arithmetic 24976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm works module 2**N for some N>PyLong_SHIFT. */ 24986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow = a->ob_digit[i] - b->ob_digit[i] - borrow; 24996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = borrow & PyLong_MASK; 25006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow >>= PyLong_SHIFT; 25016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow &= 1; /* Keep only one sign bit */ 25026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; i < size_a; ++i) { 25046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow = a->ob_digit[i] - borrow; 25056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = borrow & PyLong_MASK; 25066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow >>= PyLong_SHIFT; 25076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm borrow &= 1; /* Keep only one sign bit */ 25086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(borrow == 0); 25106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (sign < 0) 25116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 25126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(z); 25136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 25146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 25166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_add(PyLongObject *v, PyLongObject *w) 25176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 25186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *z; 25196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size < 0) { 25236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b->ob_size < 0) { 25246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_add(a, b); 25256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z != NULL && z->ob_size != 0) 25266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 25276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 25296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_sub(b, a); 25306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 25326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b->ob_size < 0) 25336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_sub(a, b); 25346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 25356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_add(a, b); 25366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 25386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 25396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 25406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 25416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 25436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_sub(PyLongObject *v, PyLongObject *w) 25446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 25456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *z; 25466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size < 0) { 25506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b->ob_size < 0) 25516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_sub(a, b); 25526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 25536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_add(a, b); 25546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z != NULL && z->ob_size != 0) 25556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 25566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 25586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b->ob_size < 0) 25596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_add(a, b); 25606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 25616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = x_sub(a, b); 25626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 25636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 25646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 25656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 25666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 25676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Grade school multiplication, ignoring the signs. 25696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * Returns the absolute value of the product, or NULL if error. 25706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 25716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 25726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmx_mul(PyLongObject *a, PyLongObject *b) 25736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 25746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 25756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a = ABS(Py_SIZE(a)); 25766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_b = ABS(Py_SIZE(b)); 25776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 25786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_a + size_b); 25806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 25816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 25826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit)); 25846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == b) { 25856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Efficient squaring per HAC, Algorithm 14.16: 25866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf 25876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * Gives slightly less than a 2x speedup when a == b, 25886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * via exploiting that each entry in the multiplication 25896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * pyramid appears twice (except for the size_a squares). 25906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 25916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_a; ++i) { 25926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits carry; 25936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits f = a->ob_digit[i]; 25946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pz = z->ob_digit + (i << 1); 25956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pa = a->ob_digit + i + 1; 25966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *paend = a->ob_digit + size_a; 25976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 25986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIGCHECK({ 25996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 26006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 26016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm }); 26026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry = *pz + f * f; 26046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz++ = (digit)(carry & PyLong_MASK); 26056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 26066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry <= PyLong_MASK); 26076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Now f is added in twice in each column of the 26096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * pyramid it appears. Same as adding f<<1 once. 26106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 26116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm f <<= 1; 26126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (pa < paend) { 26136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += *pz + *pa++ * f; 26146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz++ = (digit)(carry & PyLong_MASK); 26156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 26166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry <= (PyLong_MASK << 1)); 26176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (carry) { 26196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += *pz; 26206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz++ = (digit)(carry & PyLong_MASK); 26216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 26226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (carry) 26246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz += (digit)(carry & PyLong_MASK); 26256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert((carry >> PyLong_SHIFT) == 0); 26266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { /* a is not the same as b -- gradeschool long mult */ 26296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_a; ++i) { 26306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits carry = 0; 26316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits f = a->ob_digit[i]; 26326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pz = z->ob_digit + i; 26336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pb = b->ob_digit; 26346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit *pbend = b->ob_digit + size_b; 26356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm SIGCHECK({ 26376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 26386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 26396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm }); 26406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (pb < pbend) { 26426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += *pz + *pb++ * f; 26436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz++ = (digit)(carry & PyLong_MASK); 26446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 26456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry <= PyLong_MASK); 26466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (carry) 26486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pz += (digit)(carry & PyLong_MASK); 26496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert((carry >> PyLong_SHIFT) == 0); 26506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(z); 26536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 26546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* A helper for Karatsuba multiplication (k_mul). 26566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Takes a long "n" and an integer "size" representing the place to 26576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm split, and sets low and high such that abs(n) == (high << size) + low, 26586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm viewing the shift as being by digits. The sign bit is ignored, and 26596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the return values are >= 0. 26606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Returns 0 on success, -1 on failure. 26616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm*/ 26626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 26636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmkmul_split(PyLongObject *n, 26646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size, 26656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject **high, 26666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject **low) 26676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 26686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *hi, *lo; 26696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_lo, size_hi; 26706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const Py_ssize_t size_n = ABS(Py_SIZE(n)); 26716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_lo = MIN(size_n, size); 26736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_hi = size_n - size_lo; 26746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((hi = _PyLong_New(size_hi)) == NULL) 26766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 26776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((lo = _PyLong_New(size_lo)) == NULL) { 26786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(hi); 26796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 26806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 26816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(lo->ob_digit, n->ob_digit, size_lo * sizeof(digit)); 26836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(hi->ob_digit, n->ob_digit + size_lo, size_hi * sizeof(digit)); 26846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *high = long_normalize(hi); 26866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *low = long_normalize(lo); 26876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 26886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 26896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b); 26916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 26926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Karatsuba multiplication. Ignores the input signs, and returns the 26936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * absolute value of the product (or NULL if error). 26946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * See Knuth Vol. 2 Chapter 4.3.3 (Pp. 294-295). 26956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 26966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 26976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmk_mul(PyLongObject *a, PyLongObject *b) 26986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 26996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t asize = ABS(Py_SIZE(a)); 27006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t bsize = ABS(Py_SIZE(b)); 27016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *ah = NULL; 27026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *al = NULL; 27036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *bh = NULL; 27046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *bl = NULL; 27056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *ret = NULL; 27066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *t1, *t2, *t3; 27076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t shift; /* the number of digits we split off */ 27086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 27096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* (ah*X+al)(bh*X+bl) = ah*bh*X*X + (ah*bl + al*bh)*X + al*bl 27116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * Let k = (ah+al)*(bh+bl) = ah*bl + al*bh + ah*bh + al*bl 27126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * Then the original product is 27136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * ah*bh*X*X + (k - ah*bh - al*bl)*X + al*bl 27146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * By picking X to be a power of 2, "*X" is just shifting, and it's 27156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * been reduced to 3 multiplies on numbers half the size. 27166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 27176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* We want to split based on the larger number; fiddle so that b 27196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * is largest. 27206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 27216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (asize > bsize) { 27226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t1 = a; 27236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a = b; 27246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b = t1; 27256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = asize; 27276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm asize = bsize; 27286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bsize = i; 27296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 27306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Use gradeschool math when either number is too small. */ 27326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF; 27336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (asize <= i) { 27346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (asize == 0) 27356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_New(0); 27366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 27376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return x_mul(a, b); 27386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 27396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* If a is small compared to b, splitting on b gives a degenerate 27416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * case with ah==0, and Karatsuba may be (even much) less efficient 27426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * than "grade school" then. However, we can still win, by viewing 27436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * b as a string of "big digits", each of width a->ob_size. That 27446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * leads to a sequence of balanced calls to k_mul. 27456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 27466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (2 * asize <= bsize) 27476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return k_lopsided_mul(a, b); 27486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Split a & b into hi & lo pieces. */ 27506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift = bsize >> 1; 27516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (kmul_split(a, shift, &ah, &al) < 0) goto fail; 27526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */ 27536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == b) { 27556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bh = ah; 27566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bl = al; 27576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(bh); 27586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(bl); 27596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 27606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail; 27616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The plan: 27636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 1. Allocate result space (asize + bsize digits: that's always 27646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * enough). 27656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 2. Compute ah*bh, and copy into result at 2*shift. 27666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 3. Compute al*bl, and copy into result at 0. Note that this 27676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * can't overlap with #2. 27686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 4. Subtract al*bl from the result, starting at shift. This may 27696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * underflow (borrow out of the high digit), but we don't care: 27706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * we're effectively doing unsigned arithmetic mod 27716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * PyLong_BASE**(sizea + sizeb), and so long as the *final* result fits, 27726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * borrows and carries out of the high digit can be ignored. 27736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 5. Subtract ah*bh from the result, starting at shift. 27746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * 6. Compute (ah+al)*(bh+bl), and add it into the result starting 27756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * at shift. 27766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 27776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 1. Allocate result space. */ 27796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ret = _PyLong_New(asize + bsize); 27806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ret == NULL) goto fail; 27816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifdef Py_DEBUG 27826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Fill with trash, to catch reference to uninitialized digits. */ 27836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit)); 27846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 27856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 2. t1 <- ah*bh, and copy into high digits of result. */ 27876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((t1 = k_mul(ah, bh)) == NULL) goto fail; 27886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(t1) >= 0); 27896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret)); 27906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(ret->ob_digit + 2*shift, t1->ob_digit, 27916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(t1) * sizeof(digit)); 27926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Zero-out the digits higher than the ah*bh copy. */ 27946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1); 27956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i) 27966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0, 27976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i * sizeof(digit)); 27986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 27996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 3. t2 <- al*bl, and copy into the low digits. */ 28006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((t2 = k_mul(al, bl)) == NULL) { 28016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t1); 28026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto fail; 28036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 28046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(t2) >= 0); 28056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(t2) <= 2*shift); /* no overlap with high digits */ 28066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit)); 28076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Zero out remaining digits. */ 28096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = 2*shift - Py_SIZE(t2); /* number of uninitialized digits */ 28106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i) 28116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit)); 28126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 4 & 5. Subtract ah*bh (t1) and al*bl (t2). We do al*bl first 28146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * because it's fresher in cache. 28156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 28166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm i = Py_SIZE(ret) - shift; /* # digits after shift */ 28176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2)); 28186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t2); 28196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1)); 28216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t1); 28226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 6. t3 <- (ah+al)(bh+bl), and add into result. */ 28246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((t1 = x_add(ah, al)) == NULL) goto fail; 28256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(ah); 28266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(al); 28276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ah = al = NULL; 28286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a == b) { 28306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t2 = t1; 28316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(t2); 28326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 28336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if ((t2 = x_add(bh, bl)) == NULL) { 28346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t1); 28356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto fail; 28366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 28376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(bh); 28386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(bl); 28396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bh = bl = NULL; 28406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm t3 = k_mul(t1, t2); 28426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t1); 28436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t2); 28446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (t3 == NULL) goto fail; 28456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(Py_SIZE(t3) >= 0); 28466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Add t3. It's not obvious why we can't run out of room here. 28486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * See the (*) comment after this function. 28496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 28506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3)); 28516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(t3); 28526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(ret); 28546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm fail: 28566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(ret); 28576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(ah); 28586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(al); 28596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(bh); 28606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(bl); 28616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 28626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 28636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* (*) Why adding t3 can't "run out of room" above. 28656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmLet f(x) mean the floor of x and c(x) mean the ceiling of x. Some facts 28676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmto start with: 28686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm1. For any integer i, i = c(i/2) + f(i/2). In particular, 28706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bsize = c(bsize/2) + f(bsize/2). 28716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm2. shift = f(bsize/2) 28726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm3. asize <= bsize 28736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm4. Since we call k_lopsided_mul if asize*2 <= bsize, asize*2 > bsize in this 28746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm routine, so asize > bsize/2 >= f(bsize/2) in this routine. 28756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmWe allocated asize + bsize result digits, and add t3 into them at an offset 28776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmof shift. This leaves asize+bsize-shift allocated digit positions for t3 28786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmto fit into, = (by #1 and #2) asize + f(bsize/2) + c(bsize/2) - f(bsize/2) = 28796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmasize + c(bsize/2) available digit positions. 28806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbh has c(bsize/2) digits, and bl at most f(size/2) digits. So bh+hl has 28826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmat most c(bsize/2) digits + 1 bit. 28836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmIf asize == bsize, ah has c(bsize/2) digits, else ah has at most f(bsize/2) 28856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdigits, and al has at most f(bsize/2) digits in any case. So ah+al has at 28866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmmost (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 1 bit. 28876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmThe product (ah+al)*(bh+bl) therefore has at most 28896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c(bsize/2) + (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits 28916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 28926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmand we have asize + c(bsize/2) available digit positions. We need to show 28936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthis is always enough. An instance of c(bsize/2) cancels out in both, so 28946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthe question reduces to whether asize digits is enough to hold 28956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm(asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits. If asize < bsize, 28966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmthen we're asking whether asize digits >= f(bsize/2) digits + 2 bits. By #4, 28976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmasize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1 28986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmdigit is enough to hold 2 bits. This is so since PyLong_SHIFT=15 >= 2. If 28996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmasize == bsize, then we're asking whether bsize digits is enough to hold 29006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmc(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits 29016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmis enough to hold 2 bits. This is so if bsize >= 2, which holds because 29026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmbsize >= KARATSUBA_CUTOFF >= 2. 29036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmNote that since there's always enough room for (ah+al)*(bh+bl), and that's 29056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmclearly >= each of ah*bh and al*bl, there's always enough room to subtract 29066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmah*bh and al*bl too. 29076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm*/ 29086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* b has at least twice the digits of a, and a is big enough that Karatsuba 29106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * would pay off *if* the inputs had balanced sizes. View b as a sequence 29116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * of slices, each with a->ob_size digits, and multiply the slices by a, 29126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * one at a time. This gives k_mul balanced inputs to work with, and is 29136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * also cache-friendly (we compute one double-width slice of the result 29146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * at a time, then move on, never backtracking except for the helpful 29156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * single-width slice overlap between successive partial sums). 29166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 29176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyLongObject * 29186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmk_lopsided_mul(PyLongObject *a, PyLongObject *b) 29196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 29206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const Py_ssize_t asize = ABS(Py_SIZE(a)); 29216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t bsize = ABS(Py_SIZE(b)); 29226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t nbdone; /* # of b digits already multiplied */ 29236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *ret; 29246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *bslice = NULL; 29256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(asize > KARATSUBA_CUTOFF); 29276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(2 * asize <= bsize); 29286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Allocate result space, and zero it out. */ 29306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ret = _PyLong_New(asize + bsize); 29316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ret == NULL) 29326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 29336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit)); 29346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Successive slices of b are copied into bslice. */ 29366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bslice = _PyLong_New(asize); 29376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (bslice == NULL) 29386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto fail; 29396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nbdone = 0; 29416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (bsize > 0) { 29426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *product; 29436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const Py_ssize_t nbtouse = MIN(bsize, asize); 29446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Multiply the next slice of b by a. */ 29466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(bslice->ob_digit, b->ob_digit + nbdone, 29476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nbtouse * sizeof(digit)); 29486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(bslice) = nbtouse; 29496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm product = k_mul(a, bslice); 29506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (product == NULL) 29516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto fail; 29526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Add into result. */ 29546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone, 29556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm product->ob_digit, Py_SIZE(product)); 29566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(product); 29576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bsize -= nbtouse; 29596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nbdone += nbtouse; 29606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 29616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(bslice); 29636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_normalize(ret); 29646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm fail: 29666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(ret); 29676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(bslice); 29686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 29696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 29706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 29726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_mul(PyLongObject *v, PyLongObject *w) 29736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 29746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *z; 29756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!convert_binop((PyObject *)v, (PyObject *)w, &a, &b)) { 29776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(Py_NotImplemented); 29786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_NotImplemented; 29796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 29806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = k_mul(a, b); 29826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Negate if exactly one of the inputs is negative. */ 29836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (((a->ob_size ^ b->ob_size) < 0) && z) 29846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 29856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 29866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 29876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 29886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 29896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 29906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* The / and % operators are now defined in terms of divmod(). 29916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm The expression a mod b has the value a - b*floor(a/b). 29926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm The long_divrem function gives the remainder after division of 29936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm |a| by |b|, with the sign of a. This is also expressed 29946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm as a - b*trunc(a/b), if trunc truncates towards zero. 29956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Some examples: 29966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a b a rem b a mod b 29976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13 10 3 3 29986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm -13 10 -3 7 29996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 13 -10 3 -7 30006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm -13 -10 -3 -3 30016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm So, to get from rem to mod, we have to add b if a and b 30026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm have different signs. We then subtract one from the 'div' 30036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm part of the outcome to keep the invariant intact. */ 30046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Compute 30066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * *pdiv, *pmod = divmod(v, w) 30076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * NULL can be passed for pdiv or pmod, in which case that part of 30086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * the result is simply thrown away. The caller owns a reference to 30096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * each of these it requests (does not pass NULL for). 30106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 30116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 30126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylml_divmod(PyLongObject *v, PyLongObject *w, 30136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject **pdiv, PyLongObject **pmod) 30146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 30156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *div, *mod; 30166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (long_divrem(v, w, &div, &mod) < 0) 30186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 30196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) || 30206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) { 30216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *temp; 30226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *one; 30236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = (PyLongObject *) long_add(mod, w); 30246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(mod); 30256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm mod = temp; 30266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (mod == NULL) { 30276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(div); 30286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 30296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 30306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm one = (PyLongObject *) PyLong_FromLong(1L); 30316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (one == NULL || 30326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (temp = (PyLongObject *) long_sub(div, one)) == NULL) { 30336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(mod); 30346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(div); 30356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(one); 30366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 30376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 30386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(one); 30396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(div); 30406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm div = temp; 30416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 30426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (pdiv != NULL) 30436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pdiv = div; 30446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 30456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(div); 30466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (pmod != NULL) 30486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pmod = mod; 30496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 30506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(mod); 30516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 30536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 30546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 30566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_div(PyObject *v, PyObject *w) 30576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 30586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *div; 30596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 30616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (l_divmod(a, b, &div, NULL) < 0) 30626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm div = NULL; 30636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 30646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 30656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)div; 30666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 30676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 30696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_classic_div(PyObject *v, PyObject *w) 30706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 30716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *div; 30726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 30746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_DivisionWarningFlag && 30756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0) 30766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm div = NULL; 30776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (l_divmod(a, b, &div, NULL) < 0) 30786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm div = NULL; 30796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 30806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 30816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)div; 30826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 30836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* PyLong/PyLong -> float, with correctly rounded result. */ 30856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define MANT_DIG_DIGITS (DBL_MANT_DIG / PyLong_SHIFT) 30876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define MANT_DIG_BITS (DBL_MANT_DIG % PyLong_SHIFT) 30886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 30906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_true_divide(PyObject *v, PyObject *w) 30916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 30926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *x; 30936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t a_size, b_size, shift, extra_bits, diff, x_size, x_bits; 30946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit mask, low; 30956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int inexact, negate, a_is_small, b_is_small; 30966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double dx, result; 30976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 30986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 30996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 31016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Method in a nutshell: 31026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0. reduce to case a, b > 0; filter out obvious underflow/overflow 31046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1. choose a suitable integer 'shift' 31056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2. use integer arithmetic to compute x = floor(2**-shift*a/b) 31066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3. adjust x for correct rounding 31076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4. convert x to a double dx with the same value 31086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5. return ldexp(dx, shift). 31096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm In more detail: 31116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0. For any a, a/0 raises ZeroDivisionError; for nonzero b, 0/b 31136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm returns either 0.0 or -0.0, depending on the sign of b. For a and 31146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b both nonzero, ignore signs of a and b, and add the sign back in 31156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm at the end. Now write a_bits and b_bits for the bit lengths of a 31166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm and b respectively (that is, a_bits = 1 + floor(log_2(a)); likewise 31176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for b). Then 31186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2**(a_bits - b_bits - 1) < a/b < 2**(a_bits - b_bits + 1). 31206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm So if a_bits - b_bits > DBL_MAX_EXP then a/b > 2**DBL_MAX_EXP and 31226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm so overflows. Similarly, if a_bits - b_bits < DBL_MIN_EXP - 31236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm DBL_MANT_DIG - 1 then a/b underflows to 0. With these cases out of 31246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the way, we can assume that 31256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm DBL_MIN_EXP - DBL_MANT_DIG - 1 <= a_bits - b_bits <= DBL_MAX_EXP. 31276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 1. The integer 'shift' is chosen so that x has the right number of 31296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits for a double, plus two or three extra bits that will be used 31306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm in the rounding decisions. Writing a_bits and b_bits for the 31316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm number of significant bits in a and b respectively, a 31326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm straightforward formula for shift is: 31336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift = a_bits - b_bits - DBL_MANT_DIG - 2 31356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm This is fine in the usual case, but if a/b is smaller than the 31376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm smallest normal float then it can lead to double rounding on an 31386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm IEEE 754 platform, giving incorrectly rounded results. So we 31396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm adjust the formula slightly. The actual formula used is: 31406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift = MAX(a_bits - b_bits, DBL_MIN_EXP) - DBL_MANT_DIG - 2 31426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2. The quantity x is computed by first shifting a (left -shift bits 31446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if shift <= 0, right shift bits if shift > 0) and then dividing by 31456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b. For both the shift and the division, we keep track of whether 31466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the result is inexact, in a flag 'inexact'; this information is 31476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm needed at the rounding stage. 31486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm With the choice of shift above, together with our assumption that 31506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_bits - b_bits >= DBL_MIN_EXP - DBL_MANT_DIG - 1, it follows 31516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm that x >= 1. 31526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 3. Now x * 2**shift <= a/b < (x+1) * 2**shift. We want to replace 31546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm this with an exactly representable float of the form 31556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm round(x/2**extra_bits) * 2**(extra_bits+shift). 31576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm For float representability, we need x/2**extra_bits < 31596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2**DBL_MANT_DIG and extra_bits + shift >= DBL_MIN_EXP - 31606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm DBL_MANT_DIG. This translates to the condition: 31616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm extra_bits >= MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG 31636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm To round, we just modify the bottom digit of x in-place; this can 31656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm end up giving a digit with value > PyLONG_MASK, but that's not a 31666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm problem since digits can hold values up to 2*PyLONG_MASK+1. 31676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm With the original choices for shift above, extra_bits will always 31696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm be 2 or 3. Then rounding under the round-half-to-even rule, we 31706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm round up iff the most significant of the extra bits is 1, and 31716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm either: (a) the computation of x in step 2 had an inexact result, 31726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm or (b) at least one other of the extra bits is 1, or (c) the least 31736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm significant bit of x (above those to be rounded) is 1. 31746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 4. Conversion to a double is straightforward; all floating-point 31766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm operations involved in the conversion are exact, so there's no 31776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm danger of rounding errors. 31786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 5. Use ldexp(x, shift) to compute x*2**shift, the final result. 31806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm The result will always be exactly representable as a double, except 31816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm in the case that it overflows. To avoid dependence on the exact 31826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm behaviour of ldexp on overflow, we check for overflow before 31836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm applying ldexp. The result of ldexp is adjusted for sign before 31846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm returning. 31856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 31866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Reduce to case where a and b are both positive. */ 31886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size = ABS(Py_SIZE(a)); 31896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b_size = ABS(Py_SIZE(b)); 31906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0); 31916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b_size == 0) { 31926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ZeroDivisionError, 31936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "division by zero"); 31946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 31956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 31966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_size == 0) 31976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto underflow_or_zero; 31986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 31996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Fast path for a and b small (exactly representable in a double). 32006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Relies on floating-point division being correctly rounded; results 32016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm may be subject to double rounding on x86 machines that operate with 32026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the x87 FPU set to 64-bit precision. */ 32036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_is_small = a_size <= MANT_DIG_DIGITS || 32046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (a_size == MANT_DIG_DIGITS+1 && 32056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b_is_small = b_size <= MANT_DIG_DIGITS || 32076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (b_size == MANT_DIG_DIGITS+1 && 32086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_is_small && b_is_small) { 32106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double da, db; 32116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm da = a->ob_digit[--a_size]; 32126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (a_size > 0) 32136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm da = da * PyLong_BASE + a->ob_digit[--a_size]; 32146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm db = b->ob_digit[--b_size]; 32156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (b_size > 0) 32166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm db = db * PyLong_BASE + b->ob_digit[--b_size]; 32176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = da / db; 32186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto success; 32196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 32206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 32216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Catch obvious cases of underflow and overflow */ 32226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm diff = a_size - b_size; 32236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (diff > PY_SSIZE_T_MAX/PyLong_SHIFT - 1) 32246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Extreme overflow */ 32256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 32266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (diff < 1 - PY_SSIZE_T_MAX/PyLong_SHIFT) 32276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Extreme underflow */ 32286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto underflow_or_zero; 32296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Next line is now safe from overflowing a Py_ssize_t */ 32306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm diff = diff * PyLong_SHIFT + bits_in_digit(a->ob_digit[a_size - 1]) - 32316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm bits_in_digit(b->ob_digit[b_size - 1]); 32326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Now diff = a_bits - b_bits. */ 32336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (diff > DBL_MAX_EXP) 32346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 32356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (diff < DBL_MIN_EXP - DBL_MANT_DIG - 1) 32366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto underflow_or_zero; 32376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 32386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Choose value for shift; see comments for step 1 above. */ 32396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shift = MAX(diff, DBL_MIN_EXP) - DBL_MANT_DIG - 2; 32406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 32416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm inexact = 0; 32426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 32436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* x = abs(a * 2**-shift) */ 32446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shift <= 0) { 32456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i, shift_digits = -shift / PyLong_SHIFT; 32466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem; 32476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* x = a << -shift */ 32486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a_size >= PY_SSIZE_T_MAX - 1 - shift_digits) { 32496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* In practice, it's probably impossible to end up 32506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm here. Both a and b would have to be enormous, 32516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm using close to SIZE_T_MAX bytes of memory each. */ 32526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 32536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "intermediate overflow during division"); 32546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 32556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 32566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = _PyLong_New(a_size + shift_digits + 1); 32576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 32586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 32596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < shift_digits; i++) 32606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x->ob_digit[i] = 0; 32616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = v_lshift(x->ob_digit + shift_digits, a->ob_digit, 32626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size, -shift % PyLong_SHIFT); 32636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x->ob_digit[a_size + shift_digits] = rem; 32646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 32656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 32666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t shift_digits = shift / PyLong_SHIFT; 32676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem; 32686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* x = a >> shift */ 32696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(a_size >= shift_digits); 32706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = _PyLong_New(a_size - shift_digits); 32716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 32726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 32736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rem = v_rshift(x->ob_digit, a->ob_digit + shift_digits, 32746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a_size - shift_digits, shift % PyLong_SHIFT); 32756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* set inexact if any of the bits shifted out is nonzero */ 32766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (rem) 32776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm inexact = 1; 32786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (!inexact && shift_digits > 0) 32796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_digit[--shift_digits]) 32806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm inexact = 1; 32816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 32826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_normalize(x); 32836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size = Py_SIZE(x); 32846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 32856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* x //= b. If the remainder is nonzero, set inexact. We own the only 32866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm reference to x, so it's safe to modify it in-place. */ 32876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (b_size == 1) { 32886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit rem = inplace_divrem1(x->ob_digit, x->ob_digit, x_size, 32896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b->ob_digit[0]); 32906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_normalize(x); 32916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (rem) 32926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm inexact = 1; 32936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 32946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 32956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *div, *rem; 32966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm div = x_divrem(x, b, &rem); 32976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(x); 32986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = div; 32996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 33006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 33016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(rem)) 33026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm inexact = 1; 33036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(rem); 33046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 33056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_size = ABS(Py_SIZE(x)); 33066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(x_size > 0); /* result of division is never zero */ 33076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]); 33086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* The number of extra bits that have to be rounded away. */ 33106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm extra_bits = MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG; 33116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(extra_bits == 2 || extra_bits == 3); 33126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Round by directly modifying the low digit of x. */ 33146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm mask = (digit)1 << (extra_bits - 1); 33156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm low = x->ob_digit[0] | inexact; 33166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (low & mask && low & (3*mask-1)) 33176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm low += mask; 33186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x->ob_digit[0] = low & ~(mask-1U); 33196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Convert x to a double dx; the conversion is exact. */ 33216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx = x->ob_digit[--x_size]; 33226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (x_size > 0) 33236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm dx = dx * PyLong_BASE + x->ob_digit[--x_size]; 33246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(x); 33256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Check whether ldexp result will overflow a double. */ 33276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shift + x_bits >= DBL_MAX_EXP && 33286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (shift + x_bits > DBL_MAX_EXP || dx == ldexp(1.0, (int)x_bits))) 33296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto overflow; 33306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = ldexp(dx, (int)shift); 33316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm success: 33336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyFloat_FromDouble(negate ? -result : result); 33366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm underflow_or_zero: 33386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyFloat_FromDouble(negate ? -0.0 : 0.0); 33416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm overflow: 33436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_OverflowError, 33446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "integer division result too large for a float"); 33456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm error: 33466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 33496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 33506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 33526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_mod(PyObject *v, PyObject *w) 33536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 33546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *mod; 33556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 33576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (l_divmod(a, b, NULL, &mod) < 0) 33596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm mod = NULL; 33606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)mod; 33636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 33646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 33666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_divmod(PyObject *v, PyObject *w) 33676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 33686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *div, *mod; 33696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *z; 33706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 33726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (l_divmod(a, b, &div, &mod) < 0) { 33746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 33776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 33786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = PyTuple_New(2); 33796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z != NULL) { 33806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyTuple_SetItem(z, 0, (PyObject *) div); 33816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyTuple_SetItem(z, 1, (PyObject *) mod); 33826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 33836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 33846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(div); 33856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(mod); 33866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 33876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 33886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 33896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return z; 33906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 33916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* pow(v, w, x) */ 33936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 33946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_pow(PyObject *v, PyObject *w, PyObject *x) 33956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 33966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b, *c; /* a,b,c = v,w,x */ 33976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int negativeOutput = 0; /* if x<0 return negative output */ 33986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 33996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z = NULL; /* accumulated result */ 34006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i, j, k; /* counters */ 34016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *temp = NULL; 34026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* 5-ary values. If the exponent is large enough, table is 34046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * precomputed so that table[i] == a**i % c for i in range(32). 34056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 34066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *table[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 34076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 34086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* a, b, c = v, w, x */ 34106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 34116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_Check(x)) { 34126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = (PyLongObject *)x; 34136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(x); 34146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyInt_Check(x)) { 34166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x)); 34176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (c == NULL) 34186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (x == Py_None) 34216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = NULL; 34226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 34236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 34246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 34256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(Py_NotImplemented); 34266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_NotImplemented; 34276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(b) < 0) { /* if exponent is negative */ 34306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (c) { 34316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, "pow() 2nd argument " 34326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "cannot be negative when 3rd argument specified"); 34336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 34366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* else return a float. This works because we know 34376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm that this calls float_pow() which converts its 34386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm arguments to double. */ 34396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 34406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 34416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyFloat_Type.tp_as_number->nb_power(v, w, x); 34426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (c) { 34466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* if modulus == 0: 34476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm raise ValueError() */ 34486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(c) == 0) { 34496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, 34506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "pow() 3rd argument cannot be 0"); 34516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* if modulus < 0: 34556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negativeOutput = True 34566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm modulus = -modulus */ 34576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(c) < 0) { 34586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negativeOutput = 1; 34596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = (PyLongObject *)_PyLong_Copy(c); 34606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (temp == NULL) 34616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(c); 34636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = temp; 34646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = NULL; 34656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c->ob_size = - c->ob_size; 34666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* if modulus == 1: 34696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0 */ 34706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) { 34716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = (PyLongObject *)PyLong_FromLong(0L); 34726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Done; 34736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* if base < 0: 34766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base = base % modulus 34776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Having the base positive just makes things easier. */ 34786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(a) < 0) { 34796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (l_divmod(a, c, NULL, &temp) < 0) 34806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 34826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a = temp; 34836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = NULL; 34846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 34866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* At this point a, b, and c are guaranteed non-negative UNLESS 34886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c is NULL, in which case a may be negative. */ 34896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = (PyLongObject *)PyLong_FromLong(1L); 34916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 34926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 34936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 34946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Perform a modular reduction, X = X % c, but leave X alone if c 34956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * is NULL. 34966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 34976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define REDUCE(X) \ 34986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { \ 34996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (c != NULL) { \ 35006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (l_divmod(X, c, NULL, &temp) < 0) \ 35016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; \ 35026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(X); \ 35036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm X = temp; \ 35046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = NULL; \ 35056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } \ 35066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while(0) 35076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Multiply two values, then reduce the result: 35096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = X*Y % c. If c is NULL, skip the mod. */ 35106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#define MULT(X, Y, result) \ 35116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm do { \ 35126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = (PyLongObject *)long_mul(X, Y); \ 35136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (temp == NULL) \ 35146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; \ 35156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(result); \ 35166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = temp; \ 35176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = NULL; \ 35186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm REDUCE(result); \ 35196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } while(0) 35206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(b) <= FIVEARY_CUTOFF) { 35226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Left-to-right binary exponentiation (HAC Algorithm 14.79) */ 35236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */ 35246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit bi = b->ob_digit[i]; 35266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (j = (digit)1 << (PyLong_SHIFT-1); j != 0; j >>= 1) { 35286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm MULT(z, z, z); 35296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (bi & j) 35306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm MULT(z, a, z); 35316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 35356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Left-to-right 5-ary exponentiation (HAC Algorithm 14.82) */ 35366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(z); /* still holds 1L */ 35376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm table[0] = z; 35386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 1; i < 32; ++i) 35396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm MULT(table[i-1], a, table[i]); 35406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const digit bi = b->ob_digit[i]; 35436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) { 35456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm const int index = (bi >> j) & 0x1f; 35466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (k = 0; k < 5; ++k) 35476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm MULT(z, z, z); 35486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (index) 35496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm MULT(z, table[index], z); 35506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (negativeOutput && (Py_SIZE(z) != 0)) { 35556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = (PyLongObject *)long_sub(z, c); 35566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (temp == NULL) 35576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Error; 35586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 35596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = temp; 35606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm temp = NULL; 35616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto Done; 35636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Error: 35656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z != NULL) { 35666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(z); 35676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = NULL; 35686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* fall through */ 35706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Done: 35716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(b) > FIVEARY_CUTOFF) { 35726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < 32; ++i) 35736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(table[i]); 35746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 35756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 35766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 35776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(c); 35786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_XDECREF(temp); 35796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 35806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 35816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 35836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_invert(PyLongObject *v) 35846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 35856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Implement ~x as -(x+1) */ 35866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *x; 35876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *w; 35886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm w = (PyLongObject *)PyLong_FromLong(1L); 35896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (w == NULL) 35906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 35916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (PyLongObject *) long_add(v, w); 35926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(w); 35936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 35946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 35956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(x) = -(Py_SIZE(x)); 35966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)x; 35976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 35986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 35996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 36006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_neg(PyLongObject *v) 36016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 36026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 36036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v->ob_size == 0 && PyLong_CheckExact(v)) { 36046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* -0 == 0 */ 36056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(v); 36066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *) v; 36076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = (PyLongObject *)_PyLong_Copy(v); 36096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z != NULL) 36106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(v->ob_size); 36116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 36126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 36136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 36156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_abs(PyLongObject *v) 36166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 36176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (v->ob_size < 0) 36186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_neg(v); 36196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 36206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_long((PyObject *)v); 36216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 36226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 36246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_nonzero(PyLongObject *v) 36256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 36266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_SIZE(v) != 0; 36276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 36286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 36306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_rshift(PyLongObject *v, PyLongObject *w) 36316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 36326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b; 36336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z = NULL; 36346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t shiftby, newsize, wordshift, loshift, hishift, i, j; 36356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit lomask, himask; 36366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 36386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(a) < 0) { 36406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Right shifting negative numbers is harder */ 36416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a1, *a2; 36426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a1 = (PyLongObject *) long_invert(a); 36436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a1 == NULL) 36446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto rshift_error; 36456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a2 = (PyLongObject *) long_rshift(a1, b); 36466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a1); 36476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a2 == NULL) 36486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto rshift_error; 36496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = (PyLongObject *) long_invert(a2); 36506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a2); 36516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 36536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shiftby = PyLong_AsSsize_t((PyObject *)b); 36546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shiftby == -1L && PyErr_Occurred()) 36556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto rshift_error; 36566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shiftby < 0) { 36576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, 36586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "negative shift count"); 36596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto rshift_error; 36606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm wordshift = shiftby / PyLong_SHIFT; 36626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm newsize = ABS(Py_SIZE(a)) - wordshift; 36636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (newsize <= 0) { 36646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(0); 36656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 36666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 36676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)z; 36686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm loshift = shiftby % PyLong_SHIFT; 36706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm hishift = PyLong_SHIFT - loshift; 36716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm lomask = ((digit)1 << hishift) - 1; 36726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm himask = PyLong_MASK ^ lomask; 36736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(newsize); 36746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 36756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto rshift_error; 36766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Py_SIZE(a) < 0) 36776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(z) = -(Py_SIZE(z)); 36786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0, j = wordshift; i < newsize; i++, j++) { 36796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask; 36806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (i+1 < newsize) 36816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] |= (a->ob_digit[j+1] << hishift) & himask; 36826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = long_normalize(z); 36846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 36856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm rshift_error: 36866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 36876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 36886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *) z; 36896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 36916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 36926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 36936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_lshift(PyObject *v, PyObject *w) 36946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 36956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* This version due to Tim Peters */ 36966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b; 36976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z = NULL; 36986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t shiftby, oldsize, newsize, wordshift, remshift, i, j; 36996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm twodigits accum; 37006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 37026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm shiftby = PyLong_AsSsize_t((PyObject *)b); 37046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shiftby == -1L && PyErr_Occurred()) 37056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto lshift_error; 37066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (shiftby < 0) { 37076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_ValueError, "negative shift count"); 37086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto lshift_error; 37096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 37106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */ 37116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm wordshift = shiftby / PyLong_SHIFT; 37126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm remshift = shiftby - wordshift * PyLong_SHIFT; 37136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm oldsize = ABS(a->ob_size); 37156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm newsize = oldsize + wordshift; 37166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (remshift) 37176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ++newsize; 37186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(newsize); 37196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 37206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto lshift_error; 37216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (a->ob_size < 0) 37226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_size = -(z->ob_size); 37236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < wordshift; i++) 37246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = 0; 37256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum = 0; 37266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = wordshift, j = 0; j < oldsize; i++, j++) { 37276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum |= (twodigits)a->ob_digit[j] << remshift; 37286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = (digit)(accum & PyLong_MASK); 37296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm accum >>= PyLong_SHIFT; 37306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 37316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (remshift) 37326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[newsize-1] = (digit)accum; 37336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 37346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(!accum); 37356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = long_normalize(z); 37366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm lshift_error: 37376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 37386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 37396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *) z; 37406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 37416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Compute two's complement of digit vector a[0:m], writing result to 37436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z[0:m]. The digit vector a need not be normalized, but should not 37446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm be entirely zero. a and z may point to the same digit vector. */ 37456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic void 37476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmv_complement(digit *z, digit *a, Py_ssize_t m) 37486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 37496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i; 37506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit carry = 1; 37516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < m; ++i) { 37526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry += a[i] ^ PyLong_MASK; 37536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z[i] = carry & PyLong_MASK; 37546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm carry >>= PyLong_SHIFT; 37556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 37566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(carry == 0); 37576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 37586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Bitwise and/xor/or operations */ 37606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 37626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_bitwise(PyLongObject *a, 37636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int op, /* '&', '|', '^' */ 37646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *b) 37656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 37666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int nega, negb, negz; 37676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t size_a, size_b, size_z, i; 37686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *z; 37696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Bitwise operations for negative numbers operate as though 37716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm on a two's complement representation. So convert arguments 37726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm from sign-magnitude to two's complement, and convert the 37736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result back to sign-magnitude at the end. */ 37746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* If a is negative, replace it by its two's complement. */ 37766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_a = ABS(Py_SIZE(a)); 37776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm nega = Py_SIZE(a) < 0; 37786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (nega) { 37796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_a); 37806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) 37816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 37826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v_complement(z->ob_digit, a->ob_digit, size_a); 37836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm a = z; 37846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 37856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 37866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Keep reference count consistent. */ 37876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(a); 37886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 37896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Same for b. */ 37906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_b = ABS(Py_SIZE(b)); 37916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negb = Py_SIZE(b) < 0; 37926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (negb) { 37936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_b); 37946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) { 37956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 37966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 37976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 37986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v_complement(z->ob_digit, b->ob_digit, size_b); 37996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm b = z; 38006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 38026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(b); 38036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Swap a and b if necessary to ensure size_a >= size_b. */ 38056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (size_a < size_b) { 38066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = a; a = b; b = z; 38076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = size_a; size_a = size_b; size_b = size_z; 38086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negz = nega; nega = negb; negb = negz; 38096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* JRH: The original logic here was to allocate the result value (z) 38126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm as the longer of the two operands. However, there are some cases 38136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm where the result is guaranteed to be shorter than that: AND of two 38146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm positives, OR of two negatives: use the shorter number. AND with 38156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm mixed signs: use the positive number. OR with mixed signs: use the 38166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negative number. 38176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm */ 38186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm switch (op) { 38196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '^': 38206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negz = nega ^ negb; 38216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = size_a; 38226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '&': 38246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negz = nega & negb; 38256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = negb ? size_a : size_b; 38266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '|': 38286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm negz = nega | negb; 38296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm size_z = negb ? size_b : size_a; 38306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm default: 38326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadArgument(); 38336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 38346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* We allow an extra digit if z is negative, to make sure that 38376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the final two's complement of z doesn't overflow. */ 38386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z = _PyLong_New(size_z + negz); 38396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (z == NULL) { 38406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 38416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 38426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 38436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Compute digits for overlap of a and b. */ 38466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm switch(op) { 38476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '&': 38486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_b; ++i) 38496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = a->ob_digit[i] & b->ob_digit[i]; 38506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '|': 38526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_b; ++i) 38536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = a->ob_digit[i] | b->ob_digit[i]; 38546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm case '^': 38566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < size_b; ++i) 38576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = a->ob_digit[i] ^ b->ob_digit[i]; 38586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm break; 38596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm default: 38606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_BadArgument(); 38616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 38626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Copy any remaining digits of a, inverting if necessary. */ 38656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (op == '^' && negb) 38666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (; i < size_z; ++i) 38676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[i] = a->ob_digit[i] ^ PyLong_MASK; 38686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (i < size_z) 38696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm memcpy(&z->ob_digit[i], &a->ob_digit[i], 38706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (size_z-i)*sizeof(digit)); 38716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Complement result if negative. */ 38736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (negz) { 38746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(z) = -(Py_SIZE(z)); 38756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm z->ob_digit[size_z] = PyLong_MASK; 38766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v_complement(z->ob_digit, z->ob_digit, size_z+1); 38776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 38786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 38806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 38816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)long_normalize(z); 38826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 38836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 38856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_and(PyObject *v, PyObject *w) 38866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 38876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b; 38886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *c; 38896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 38906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = long_bitwise(a, '&', b); 38916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 38926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 38936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return c; 38946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 38956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 38966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 38976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_xor(PyObject *v, PyObject *w) 38986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 38996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b; 39006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *c; 39016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 39026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = long_bitwise(a, '^', b); 39036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 39046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 39056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return c; 39066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_or(PyObject *v, PyObject *w) 39106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *a, *b; 39126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *c; 39136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm CONVERT_BINOP(v, w, &a, &b); 39146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm c = long_bitwise(a, '|', b); 39156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(a); 39166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(b); 39176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return c; 39186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic int 39216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_coerce(PyObject **pv, PyObject **pw) 39226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyInt_Check(*pw)) { 39246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm *pw = PyLong_FromLong(PyInt_AS_LONG(*pw)); 39256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (*pw == NULL) 39266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return -1; 39276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(*pv); 39286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 39296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 39306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyLong_Check(*pw)) { 39316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(*pv); 39326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(*pw); 39336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 0; 39346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 39356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 1; /* Can't do it */ 39366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_long(PyObject *v) 39406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_CheckExact(v)) 39426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(v); 39436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 39446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm v = _PyLong_Copy((PyLongObject *)v); 39456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return v; 39466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_int(PyObject *v) 39506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long x; 39526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = PyLong_AsLong(v); 39536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyErr_Occurred()) { 39546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyErr_ExceptionMatches(PyExc_OverflowError)) { 39556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_Clear(); 39566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyLong_CheckExact(v)) { 39576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_INCREF(v); 39586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return v; 39596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 39606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 39616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_Copy((PyLongObject *)v); 39626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 39636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else 39646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 39656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 39666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromLong(x); 39676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_float(PyObject *v) 39716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm double result; 39736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = PyLong_AsDouble(v); 39746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (result == -1.0 && PyErr_Occurred()) 39756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 39766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyFloat_FromDouble(result); 39776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_oct(PyObject *v) 39816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_Format(v, 8, 1, 0); 39836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_hex(PyObject *v) 39876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_Format(v, 16, 1, 0); 39896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 39906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 39936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 39946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 39956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 39966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 39976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *x = NULL; 39986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int base = -909; /* unlikely! */ 39996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm static char *kwlist[] = {"x", "base", 0}; 40006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (type != &PyLong_Type) 40026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_subtype_new(type, args, kwds); /* Wimp out */ 40036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:long", kwlist, 40046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm &x, &base)) 40056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 40076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromLong(0L); 40086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (base == -909) 40096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyNumber_Long(x); 40106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyString_Check(x)) { 40116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Since PyLong_FromString doesn't have a length parameter, 40126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * check here for possible NULs in the string. */ 40136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm char *string = PyString_AS_STRING(x); 40146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (strlen(string) != (size_t)PyString_Size(x)) { 40156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* create a repr() of the input string, 40166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm * just like PyLong_FromString does. */ 40176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *srepr; 40186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm srepr = PyObject_Repr(x); 40196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (srepr == NULL) 40206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_Format(PyExc_ValueError, 40226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "invalid literal for long() with base %d: %s", 40236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base, PyString_AS_STRING(srepr)); 40246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(srepr); 40256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 40276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromString(PyString_AS_STRING(x), NULL, base); 40286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 40296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#ifdef Py_USING_UNICODE 40306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else if (PyUnicode_Check(x)) 40316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x), 40326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyUnicode_GET_SIZE(x), 40336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm base); 40346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 40356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm else { 40366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, 40376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long() can't convert non-string with explicit base"); 40386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 40406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 40416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm/* Wimpy, slow approach to tp_new calls for subtypes of long: 40436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm first create a regular long from whatever arguments we got, 40446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm then allocate a subtype instance and initialize it from 40456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm the regular long. The regular long is then thrown away. 40466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm*/ 40476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 40486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 40496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 40506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *tmp, *newobj; 40516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t i, n; 40526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyType_IsSubtype(type, &PyLong_Type)); 40546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); 40556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (tmp == NULL) 40566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyLong_CheckExact(tmp)); 40586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n = Py_SIZE(tmp); 40596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (n < 0) 40606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm n = -n; 40616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm newobj = (PyLongObject *)type->tp_alloc(type, n); 40626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (newobj == NULL) { 40636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(tmp); 40646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 40666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyLong_Check(newobj)); 40676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_SIZE(newobj) = Py_SIZE(tmp); 40686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm for (i = 0; i < n; i++) 40696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm newobj->ob_digit[i] = tmp->ob_digit[i]; 40706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(tmp); 40716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)newobj; 40726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 40736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 40756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_getnewargs(PyLongObject *v) 40766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 40776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return Py_BuildValue("(N)", _PyLong_Copy(v)); 40786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 40796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 40816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_get0(PyLongObject *v, void *context) { 40826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromLong(0L); 40836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 40846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 40866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_get1(PyLongObject *v, void *context) { 40876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyLong_FromLong(1L); 40886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 40896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 40916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong__format__(PyObject *self, PyObject *args) 40926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 40936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *format_spec; 40946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 40956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) 40966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 40976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyBytes_Check(format_spec)) 40986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return _PyLong_FormatAdvanced(self, 40996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyBytes_AS_STRING(format_spec), 41006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyBytes_GET_SIZE(format_spec)); 41016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyUnicode_Check(format_spec)) { 41026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* Convert format_spec to a str */ 41036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *result; 41046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject *str_spec = PyObject_Str(format_spec); 41056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (str_spec == NULL) 41076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 41086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = _PyLong_FormatAdvanced(self, 41106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyBytes_AS_STRING(str_spec), 41116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyBytes_GET_SIZE(str_spec)); 41126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(str_spec); 41146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return result; 41156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 41166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); 41176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 41186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 41196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 41216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_sizeof(PyLongObject *v) 41226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 41236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t res; 41246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm res = v->ob_type->tp_basicsize + ABS(Py_SIZE(v))*sizeof(digit); 41266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromSsize_t(res); 41276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 41286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 41306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_bit_length(PyLongObject *v) 41316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 41326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyLongObject *result, *x, *y; 41336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_ssize_t ndigits, msd_bits = 0; 41346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm digit msd; 41356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(v != NULL); 41376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm assert(PyLong_Check(v)); 41386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm ndigits = ABS(Py_SIZE(v)); 41406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ndigits == 0) 41416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromLong(0); 41426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm msd = v->ob_digit[ndigits-1]; 41446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm while (msd >= 32) { 41456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm msd_bits += 6; 41466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm msd >>= 6; 41476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 41486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm msd_bits += (long)(BitLengthTable[msd]); 41496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (ndigits <= PY_SSIZE_T_MAX/PyLong_SHIFT) 41516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return PyInt_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits); 41526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* expression above may overflow; use Python integers instead */ 41546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = (PyLongObject *)PyLong_FromSsize_t(ndigits - 1); 41556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (result == NULL) 41566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 41576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (PyLongObject *)PyLong_FromLong(PyLong_SHIFT); 41586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 41596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 41606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm y = (PyLongObject *)long_mul(result, x); 41616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(x); 41626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (y == NULL) 41636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 41646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(result); 41656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = y; 41666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm x = (PyLongObject *)PyLong_FromLong((long)msd_bits); 41686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (x == NULL) 41696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 41706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm y = (PyLongObject *)long_add(result, x); 41716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(x); 41726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (y == NULL) 41736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm goto error; 41746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(result); 41756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm result = y; 41766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return (PyObject *)result; 41786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm error: 41806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_DECREF(result); 41816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 41826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 41836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyDoc_STRVAR(long_bit_length_doc, 41856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm"long.bit_length() -> int or long\n\ 41866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm\n\ 41876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmNumber of bits necessary to represent self in binary.\n\ 41886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm>>> bin(37L)\n\ 41896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm'0b100101'\n\ 41906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm>>> (37L).bit_length()\n\ 41916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm6"); 41926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 41936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if 0 41946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyObject * 41956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmlong_is_finite(PyObject *v) 41966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 41976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_RETURN_TRUE; 41986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 41996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 42006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 42016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyMethodDef long_methods[] = { 42026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"conjugate", (PyCFunction)long_long, METH_NOARGS, 42036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "Returns self, the complex conjugate of any long."}, 42046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"bit_length", (PyCFunction)long_bit_length, METH_NOARGS, 42056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_bit_length_doc}, 42066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#if 0 42076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"is_finite", (PyCFunction)long_is_finite, METH_NOARGS, 42086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "Returns always True."}, 42096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm#endif 42106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"__trunc__", (PyCFunction)long_long, METH_NOARGS, 42116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "Truncating an Integral returns itself."}, 42126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS}, 42136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"__format__", (PyCFunction)long__format__, METH_VARARGS}, 42146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS, 42156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "Returns size in memory, in bytes"}, 42166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {NULL, NULL} /* sentinel */ 42176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 42186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 42196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyGetSetDef long_getset[] = { 42206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"real", 42216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (getter)long_long, (setter)NULL, 42226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "the real part of a complex number", 42236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm NULL}, 42246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"imag", 42256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (getter)long_get0, (setter)NULL, 42266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "the imaginary part of a complex number", 42276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm NULL}, 42286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"numerator", 42296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (getter)long_long, (setter)NULL, 42306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "the numerator of a rational number in lowest terms", 42316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm NULL}, 42326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"denominator", 42336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (getter)long_get1, (setter)NULL, 42346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "the denominator of a rational number in lowest terms", 42356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm NULL}, 42366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {NULL} /* Sentinel */ 42376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 42386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 42396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyDoc_STRVAR(long_doc, 42406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm"long(x[, base]) -> integer\n\ 42416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm\n\ 42426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmConvert a string or number to a long integer, if possible. A floating\n\ 42436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmpoint argument will be truncated towards zero (this does not include a\n\ 42446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstring representation of a floating point number!) When converting a\n\ 42456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstring, use the optional base. It is an error to supply a base when\n\ 42466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmconverting a non-string."); 42476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 42486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyNumberMethods long_as_number = { 42496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (binaryfunc)long_add, /*nb_add*/ 42506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (binaryfunc)long_sub, /*nb_subtract*/ 42516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (binaryfunc)long_mul, /*nb_multiply*/ 42526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_classic_div, /*nb_divide*/ 42536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_mod, /*nb_remainder*/ 42546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_divmod, /*nb_divmod*/ 42556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_pow, /*nb_power*/ 42566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (unaryfunc)long_neg, /*nb_negative*/ 42576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (unaryfunc)long_long, /*tp_positive*/ 42586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (unaryfunc)long_abs, /*tp_absolute*/ 42596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (inquiry)long_nonzero, /*tp_nonzero*/ 42606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (unaryfunc)long_invert, /*nb_invert*/ 42616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_lshift, /*nb_lshift*/ 42626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (binaryfunc)long_rshift, /*nb_rshift*/ 42636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_and, /*nb_and*/ 42646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_xor, /*nb_xor*/ 42656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_or, /*nb_or*/ 42666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_coerce, /*nb_coerce*/ 42676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_int, /*nb_int*/ 42686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_long, /*nb_long*/ 42696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_float, /*nb_float*/ 42706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_oct, /*nb_oct*/ 42716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_hex, /*nb_hex*/ 42726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_add */ 42736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_subtract */ 42746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_multiply */ 42756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_divide */ 42766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_remainder */ 42776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_power */ 42786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_lshift */ 42796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_rshift */ 42806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_and */ 42816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_xor */ 42826c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_or */ 42836c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_div, /* nb_floor_divide */ 42846c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_true_divide, /* nb_true_divide */ 42856c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_floor_divide */ 42866c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* nb_inplace_true_divide */ 42876c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_long, /* nb_index */ 42886c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 42896c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 42906c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyTypeObject PyLong_Type = { 42916c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject_HEAD_INIT(&PyType_Type) 42926c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* ob_size */ 42936c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "long", /* tp_name */ 42946c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm offsetof(PyLongObject, ob_digit), /* tp_basicsize */ 42956c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm sizeof(digit), /* tp_itemsize */ 42966c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_dealloc, /* tp_dealloc */ 42976c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_print */ 42986c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_getattr */ 42996c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_setattr */ 43006c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (cmpfunc)long_compare, /* tp_compare */ 43016c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_repr, /* tp_repr */ 43026c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm &long_as_number, /* tp_as_number */ 43036c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_as_sequence */ 43046c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_as_mapping */ 43056c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm (hashfunc)long_hash, /* tp_hash */ 43066c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_call */ 43076c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_str, /* tp_str */ 43086c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject_GenericGetAttr, /* tp_getattro */ 43096c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_setattro */ 43106c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_as_buffer */ 43116c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | 43126c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */ 43136c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_doc, /* tp_doc */ 43146c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_traverse */ 43156c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_clear */ 43166c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_richcompare */ 43176c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_weaklistoffset */ 43186c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_iter */ 43196c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_iternext */ 43206c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_methods, /* tp_methods */ 43216c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_members */ 43226c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_getset, /* tp_getset */ 43236c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_base */ 43246c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_dict */ 43256c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_descr_get */ 43266c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_descr_set */ 43276c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_dictoffset */ 43286c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_init */ 43296c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 0, /* tp_alloc */ 43306c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_new, /* tp_new */ 43316c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject_Del, /* tp_free */ 43326c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 43336c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43346c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyTypeObject Long_InfoType; 43356c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43366c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyDoc_STRVAR(long_info__doc__, 43376c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm"sys.long_info\n\ 43386c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm\n\ 43396c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmA struct sequence that holds information about Python's\n\ 43406c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylminternal representation of integers. The attributes are read only."); 43416c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43426c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyStructSequence_Field long_info_fields[] = { 43436c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"bits_per_digit", "size of a digit in bits"}, 43446c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {"sizeof_digit", "size in bytes of the C type used to represent a digit"}, 43456c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm {NULL, NULL} 43466c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 43476c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43486c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmstatic PyStructSequence_Desc long_info_desc = { 43496c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm "sys.long_info", /* name */ 43506c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_info__doc__, /* doc */ 43516c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_info_fields, /* fields */ 43526c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 2 /* number of fields */ 43536c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm}; 43546c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43556c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyObject * 43566c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmPyLong_GetInfo(void) 43576c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 43586c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyObject* long_info; 43596c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm int field = 0; 43606c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm long_info = PyStructSequence_New(&Long_InfoType); 43616c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (long_info == NULL) 43626c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 43636c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyStructSequence_SET_ITEM(long_info, field++, 43646c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyInt_FromLong(PyLong_SHIFT)); 43656c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyStructSequence_SET_ITEM(long_info, field++, 43666c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyInt_FromLong(sizeof(digit))); 43676c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (PyErr_Occurred()) { 43686c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm Py_CLEAR(long_info); 43696c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return NULL; 43706c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm } 43716c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return long_info; 43726c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 43736c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm 43746c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylmint 43756c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm_PyLong_Init(void) 43766c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm{ 43776c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm /* initialize long_info */ 43786c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm if (Long_InfoType.tp_name == 0) 43796c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm PyStructSequence_InitType(&Long_InfoType, &long_info_desc); 43806c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm return 1; 43816c0ebd5f2f53d5c4d6a91fd0b9148ba23e730c39darylm} 4382