cpython-lru_cache-weakref: Objects/longobject.c annotate

annotate Objects/longobject.c @ 39042:c02fa187e0f4 legacy-trunk

Part of SF patch #1484695. This removes dead code. The chksum was already verified in .frombuf() on the lines above. If there was a problem an exception is raised, so there was no way this condition could have been true.

author	Neal Norwitz <nnorwitz@gmail.com>
date	Mon, 10 Jul 2006 00:23:17 +0000
parents	7f1f36b3c9f9
children	bda93b45ca41

rev	line source
35999 9541369b0dca Add const to several API functions that take char . Jeremy Hylton <jeremy@alum.mit.edu>* parents: 35254 diff changeset	1
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3 /* Long (arbitrary precision) integer object implementation */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	4
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	5 /* XXX The functional organization of this file is terrible */
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	6
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	7 #include "Python.h"
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	8 #include "longintrepr.h"
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	9
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	10 #include <ctype.h>
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	11
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	12 /* For long multiplication, use the O(N**2) school algorithm unless
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	13 * both operands contain more than KARATSUBA_CUTOFF digits (this
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	14 * being an internal Python long digit, in base BASE).
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	15 */
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	16 #define KARATSUBA_CUTOFF 70
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	17 #define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF)
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	18
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	19 /* For exponentiation, use the binary left-to-right algorithm
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	20 * unless the exponent contains more than FIVEARY_CUTOFF digits.
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	21 * In that case, do 5 bits at a time. The potential drawback is that
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	22 * a table of 2**5 intermediate results is computed.
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	23 */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	24 #define FIVEARY_CUTOFF 8
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	25
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	26 #define ABS(x) ((x) < 0 ? -(x) : (x))
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	27
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	28 #undef MIN
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	29 #undef MAX
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	30 #define MAX(x, y) ((x) < (y) ? (y) : (x))
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	31 #define MIN(x, y) ((x) > (y) ? (y) : (x))
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	32
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	33 /* Forward */
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	34 static PyLongObject long_normalize(PyLongObject );
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	35 static PyLongObject mul1(PyLongObject , wdigit);
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	36 static PyLongObject muladd1(PyLongObject , wdigit, wdigit);
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	37 static PyLongObject divrem1(PyLongObject , digit, digit *);
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	38 static PyObject long_format(PyObject aa, int base, int addL);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	39
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	40 #define SIGCHECK(PyTryBlock) \
25108 3a26e352f0a6 replace thread state objects' ticker and checkinterval fields with two Skip Montanaro <skip@pobox.com> parents: 24919 diff changeset	41 if (--_Py_Ticker < 0) { \
3a26e352f0a6 replace thread state objects' ticker and checkinterval fields with two Skip Montanaro <skip@pobox.com> parents: 24919 diff changeset	42 _Py_Ticker = _Py_CheckInterval; \
38331 7a6af4a143c6 Patch #1494387: SVN longobject.c compiler warnings Tim Peters <tim.peters@gmail.com> parents: 38307 diff changeset	43 if (PyErr_CheckSignals()) PyTryBlock \
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	44 }
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	45
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	46 /* Normalize (remove leading zeros from) a long int object.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	47 Doesn't attempt to free the storage--in most cases, due to the nature
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	48 of the algorithms used, this could save at most be one word anyway. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	49
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	50 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	51 long_normalize(register PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	52 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	53 Py_ssize_t j = ABS(v->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	54 Py_ssize_t i = j;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	55
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	56 while (i > 0 && v->ob_digit[i-1] == 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	57 --i;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	58 if (i != j)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	59 v->ob_size = (v->ob_size < 0) ? -(i) : i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	60 return v;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	61 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	62
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	63 /* Allocate a new long int object with size digits.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	64 Return NULL and set exception if we run out of memory. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	65
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	66 PyLongObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	67 _PyLong_New(Py_ssize_t size)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	68 {
38139 f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	69 if (size > PY_SSIZE_T_MAX) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	70 PyErr_NoMemory();
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	71 return NULL;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	72 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	73 return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	74 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	75
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	76 PyObject *
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	77 _PyLong_Copy(PyLongObject *src)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	78 {
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	79 PyLongObject *result;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	80 Py_ssize_t i;
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	81
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	82 assert(src != NULL);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	83 i = src->ob_size;
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	84 if (i < 0)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	85 i = -(i);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	86 result = _PyLong_New(i);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	87 if (result != NULL) {
22147 1d1a01d956a2 backport tim_one's checkin of Michael W. Hudson <mwh@python.net> parents: 21968 diff changeset	88 result->ob_size = src->ob_size;
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	89 while (--i >= 0)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	90 result->ob_digit[i] = src->ob_digit[i];
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	91 }
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	92 return (PyObject *)result;
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	93 }
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	94
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	95 /* Create a new long int object from a C long int */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	96
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	97 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	98 PyLong_FromLong(long ival)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	99 {
18114 31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	100 PyLongObject *v;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	101 unsigned long t; /* unsigned so >> doesn't propagate sign bit */
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	102 int ndigits = 0;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	103 int negative = 0;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	104
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	105 if (ival < 0) {
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	106 ival = -ival;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	107 negative = 1;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	108 }
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	109
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	110 /* Count the number of Python digits.
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	111 We used to pick 5 ("big enough for anything"), but that's a
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	112 waste of time and space given that 5*15 = 75 bits are rarely
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	113 needed. */
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	114 t = (unsigned long)ival;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	115 while (t) {
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	116 ++ndigits;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	117 t >>= SHIFT;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	118 }
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	119 v = _PyLong_New(ndigits);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	120 if (v != NULL) {
18114 31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	121 digit *p = v->ob_digit;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	122 v->ob_size = negative ? -ndigits : ndigits;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	123 t = (unsigned long)ival;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	124 while (t) {
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	125 *p++ = (digit)(t & MASK);
4587 09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	126 t >>= SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	127 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	128 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	129 return (PyObject *)v;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	130 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	131
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	132 /* Create a new long int object from a C unsigned long int */
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	133
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	134 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	135 PyLong_FromUnsignedLong(unsigned long ival)
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	136 {
18114 31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	137 PyLongObject *v;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	138 unsigned long t;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	139 int ndigits = 0;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	140
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	141 /* Count the number of Python digits. */
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	142 t = (unsigned long)ival;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	143 while (t) {
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	144 ++ndigits;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	145 t >>= SHIFT;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	146 }
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	147 v = _PyLong_New(ndigits);
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	148 if (v != NULL) {
18114 31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	149 digit *p = v->ob_digit;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	150 v->ob_size = ndigits;
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	151 while (ival) {
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	152 *p++ = (digit)(ival & MASK);
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	153 ival >>= SHIFT;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	154 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	155 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	156 return (PyObject *)v;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	157 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	158
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	159 /* Create a new long int object from a C double */
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	160
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	161 PyObject *
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	162 PyLong_FromDouble(double dval)
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	163 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	164 PyLongObject *v;
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	165 double frac;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	166 int i, ndig, expo, neg;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	167 neg = 0;
13976 5ada9fa54801 Fix for http://sourceforge.net/bugs/?func=detailbug&bug_id=111866&group_id=5470. Tim Peters <tim.peters@gmail.com> parents: 13761 diff changeset	168 if (Py_IS_INFINITY(dval)) {
11331 4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	169 PyErr_SetString(PyExc_OverflowError,
4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	170 "cannot convert float infinity to long");
4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	171 return NULL;
4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	172 }
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	173 if (dval < 0.0) {
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	174 neg = 1;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	175 dval = -dval;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	176 }
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	177 frac = frexp(dval, &expo); /* dval = frac2expo; 0.0 <= frac < 1.0 /
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	178 if (expo <= 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	179 return PyLong_FromLong(0L);
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	180 ndig = (expo-1) / SHIFT + 1; /* Number of 'digits' in result */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	181 v = _PyLong_New(ndig);
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	182 if (v == NULL)
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	183 return NULL;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	184 frac = ldexp(frac, (expo-1) % SHIFT + 1);
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	185 for (i = ndig; --i >= 0; ) {
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	186 long bits = (long)frac;
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	187 v->ob_digit[i] = (digit) bits;
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	188 frac = frac - (double)bits;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	189 frac = ldexp(frac, SHIFT);
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	190 }
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	191 if (neg)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	192 v->ob_size = -(v->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	193 return (PyObject *)v;
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	194 }
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	195
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	196 /* Get a C long int from a long int object.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	197 Returns -1 and sets an error condition if overflow occurs. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	198
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	199 long
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	200 PyLong_AsLong(PyObject *vv)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	201 {
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	202 /* This version by Tim Peters */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	203 register PyLongObject *v;
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	204 unsigned long x, prev;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	205 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	206 int sign;
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	207
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	208 if (vv == NULL \|\| !PyLong_Check(vv)) {
19925 df409844b659 A fix for SF bug #461546 (bug in long_mul). Guido van Rossum <guido@python.org> parents: 19897 diff changeset	209 if (vv != NULL && PyInt_Check(vv))
df409844b659 A fix for SF bug #461546 (bug in long_mul). Guido van Rossum <guido@python.org> parents: 19897 diff changeset	210 return PyInt_AsLong(vv);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	211 PyErr_BadInternalCall();
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	212 return -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	213 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	214 v = (PyLongObject *)vv;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	215 i = v->ob_size;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	216 sign = 1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	217 x = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	218 if (i < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	219 sign = -1;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	220 i = -(i);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	221 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	222 while (--i >= 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	223 prev = x;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	224 x = (x << SHIFT) + v->ob_digit[i];
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	225 if ((x >> SHIFT) != prev)
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	226 goto overflow;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	227 }
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	228 /* Haven't lost any bits, but if the sign bit is set we're in
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	229 * trouble unless this is the min negative number. So,
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	230 * trouble iff sign bit set && (positive \|\| some bit set other
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	231 * than the sign bit).
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	232 */
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	233 if ((long)x < 0 && (sign > 0 \|\| (x << 1) != 0))
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	234 goto overflow;
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	235 return (long)x * sign;
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	236
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	237 overflow:
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	238 PyErr_SetString(PyExc_OverflowError,
19897 84376356ff89 based upon a suggestion in c.l.py, this slight expansion of the Skip Montanaro <skip@pobox.com> parents: 19882 diff changeset	239 "long int too large to convert to int");
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	240 return -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	241 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	242
36882 6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	243 static Py_ssize_t
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	244 _long_as_ssize_t(PyObject *vv) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	245 register PyLongObject *v;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	246 size_t x, prev;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	247 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	248 int sign;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	249
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	250 if (vv == NULL \|\| !PyLong_Check(vv)) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	251 PyErr_BadInternalCall();
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	252 return -1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	253 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	254 v = (PyLongObject *)vv;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	255 i = v->ob_size;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	256 sign = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	257 x = 0;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	258 if (i < 0) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	259 sign = -1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	260 i = -(i);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	261 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	262 while (--i >= 0) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	263 prev = x;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	264 x = (x << SHIFT) + v->ob_digit[i];
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	265 if ((x >> SHIFT) != prev)
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	266 goto overflow;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	267 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	268 /* Haven't lost any bits, but if the sign bit is set we're in
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	269 * trouble unless this is the min negative number. So,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	270 * trouble iff sign bit set && (positive \|\| some bit set other
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	271 * than the sign bit).
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	272 */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	273 if ((Py_ssize_t)x < 0 && (sign > 0 \|\| (x << 1) != 0))
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	274 goto overflow;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	275 return (Py_ssize_t)x * sign;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	276
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	277 overflow:
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	278 PyErr_SetString(PyExc_OverflowError,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	279 "long int too large to convert to int");
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	280 if (sign > 0)
36882 6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	281 return PY_SSIZE_T_MAX;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	282 else
37494 976c01091b38 Add PY_SSIZE_T_MIN, as suggested by Ralf W. Grosse-Kunstleve. Martin v. Löwis <martin@v.loewis.de> parents: 37304 diff changeset	283 return PY_SSIZE_T_MIN;
36882 6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	284 }
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	285
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	286 /* Get a Py_ssize_t from a long int object.
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	287 Returns -1 and sets an error condition if overflow occurs. */
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	288
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	289 Py_ssize_t
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	290 _PyLong_AsSsize_t(PyObject *vv)
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	291 {
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	292 Py_ssize_t x;
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	293
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	294 x = _long_as_ssize_t(vv);
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	295 if (PyErr_Occurred()) return -1;
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	296 return x;
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	297 }
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	298
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	299
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	300 /* Get a Py_ssize_t from a long int object.
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	301 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	302 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
37288 1f61aa46fee5 fix a comment. Armin Rigo <arigo@tunes.org> parents: 36882 diff changeset	303 On error, return -1 with an exception set.
36882 6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	304 */
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	305
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	306 static Py_ssize_t
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	307 long_index(PyObject *vv)
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	308 {
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	309 Py_ssize_t x;
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	310
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	311 x = _long_as_ssize_t(vv);
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	312 if (PyErr_Occurred()) {
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	313 /* If overflow error, ignore the error */
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	314 if (x != -1) {
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	315 PyErr_Clear();
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	316 }
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	317 }
6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	318 return x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	319 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	320
24777 696a284569e6 Fix comment for PyLong_AsUnsignedLong() to say that the return value Guido van Rossum <guido@python.org> parents: 24775 diff changeset	321 /* Get a C unsigned long int from a long int object.
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	322 Returns -1 and sets an error condition if overflow occurs. */
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	323
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	324 unsigned long
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	325 PyLong_AsUnsignedLong(PyObject *vv)
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	326 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	327 register PyLongObject *v;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	328 unsigned long x, prev;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	329 Py_ssize_t i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	330
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	331 if (vv == NULL \|\| !PyLong_Check(vv)) {
33524 30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	332 if (vv != NULL && PyInt_Check(vv)) {
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	333 long val = PyInt_AsLong(vv);
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	334 if (val < 0) {
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	335 PyErr_SetString(PyExc_OverflowError,
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	336 "can't convert negative value to unsigned long");
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	337 return (unsigned long) -1;
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	338 }
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	339 return val;
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	340 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	341 PyErr_BadInternalCall();
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	342 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	343 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	344 v = (PyLongObject *)vv;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	345 i = v->ob_size;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	346 x = 0;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	347 if (i < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	348 PyErr_SetString(PyExc_OverflowError,
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	349 "can't convert negative value to unsigned long");
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	350 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	351 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	352 while (--i >= 0) {
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	353 prev = x;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	354 x = (x << SHIFT) + v->ob_digit[i];
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	355 if ((x >> SHIFT) != prev) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	356 PyErr_SetString(PyExc_OverflowError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	357 "long int too large to convert");
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	358 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	359 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	360 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	361 return x;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	362 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	363
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	364 /* Get a C unsigned long int from a long int object, ignoring the high bits.
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	365 Returns -1 and sets an error condition if an error occurs. */
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	366
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	367 unsigned long
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	368 PyLong_AsUnsignedLongMask(PyObject *vv)
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	369 {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	370 register PyLongObject *v;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	371 unsigned long x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	372 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	373 int sign;
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	374
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	375 if (vv == NULL \|\| !PyLong_Check(vv)) {
33524 30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	376 if (vv != NULL && PyInt_Check(vv))
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	377 return PyInt_AsUnsignedLongMask(vv);
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	378 PyErr_BadInternalCall();
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	379 return (unsigned long) -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	380 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	381 v = (PyLongObject *)vv;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	382 i = v->ob_size;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	383 sign = 1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	384 x = 0;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	385 if (i < 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	386 sign = -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	387 i = -i;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	388 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	389 while (--i >= 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	390 x = (x << SHIFT) + v->ob_digit[i];
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	391 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	392 return x * sign;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	393 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	394
27549 7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	395 int
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	396 _PyLong_Sign(PyObject *vv)
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	397 {
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	398 PyLongObject v = (PyLongObject )vv;
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	399
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	400 assert(v != NULL);
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	401 assert(PyLong_Check(v));
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	402
27585 a05814184e8c cPickle.c: Full support for the new LONG1 and LONG4. Added comments. Tim Peters <tim.peters@gmail.com> parents: 27567 diff changeset	403 return v->ob_size == 0 ? 0 : (v->ob_size < 0 ? -1 : 1);
27549 7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	404 }
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	405
27487 0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	406 size_t
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	407 _PyLong_NumBits(PyObject *vv)
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	408 {
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	409 PyLongObject v = (PyLongObject )vv;
27549 7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	410 size_t result = 0;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	411 Py_ssize_t ndigits;
27487 0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	412
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	413 assert(v != NULL);
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	414 assert(PyLong_Check(v));
27639 6205da383e4c _PyLong_Sign(): remove an assert that needed a variable ndigits that Guido van Rossum <guido@python.org> parents: 27597 diff changeset	415 ndigits = ABS(v->ob_size);
27487 0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	416 assert(ndigits == 0 \|\| v->ob_digit[ndigits - 1] != 0);
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	417 if (ndigits > 0) {
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	418 digit msd = v->ob_digit[ndigits - 1];
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	419
27549 7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	420 result = (ndigits - 1) * SHIFT;
37815 20cb13bdf1f0 C++ compiler cleanup: bunch-o-casts, plus use of unsigned loop index var in a couple places Skip Montanaro <skip@pobox.com> parents: 37611 diff changeset	421 if (result / SHIFT != (size_t)(ndigits - 1))
27487 0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	422 goto Overflow;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	423 do {
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	424 ++result;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	425 if (result == 0)
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	426 goto Overflow;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	427 msd >>= 1;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	428 } while (msd);
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	429 }
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	430 return result;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	431
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	432 Overflow:
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	433 PyErr_SetString(PyExc_OverflowError, "long has too many bits "
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	434 "to express in a platform size_t");
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	435 return (size_t)-1;
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	436 }
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	437
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	438 PyObject *
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	439 _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	440 int little_endian, int is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	441 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	442 const unsigned char* pstartbyte;/* LSB of bytes */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	443 int incr; /* direction to move pstartbyte */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	444 const unsigned char* pendbyte; /* MSB of bytes */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	445 size_t numsignificantbytes; /* number of bytes that matter */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	446 size_t ndigits; /* number of Python long digits */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	447 PyLongObject* v; /* result */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	448 int idigit = 0; /* next free index in v->ob_digit */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	449
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	450 if (n == 0)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	451 return PyLong_FromLong(0L);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	452
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	453 if (little_endian) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	454 pstartbyte = bytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	455 pendbyte = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	456 incr = 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	457 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	458 else {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	459 pstartbyte = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	460 pendbyte = bytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	461 incr = -1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	462 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	463
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	464 if (is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	465 is_signed = *pendbyte >= 0x80;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	466
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	467 /* Compute numsignificantbytes. This consists of finding the most
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	468 significant byte. Leading 0 bytes are insignficant if the number
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	469 is positive, and leading 0xff bytes if negative. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	470 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	471 size_t i;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	472 const unsigned char* p = pendbyte;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	473 const int pincr = -incr; /* search MSB to LSB */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	474 const unsigned char insignficant = is_signed ? 0xff : 0x00;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	475
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	476 for (i = 0; i < n; ++i, p += pincr) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	477 if (*p != insignficant)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	478 break;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	479 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	480 numsignificantbytes = n - i;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	481 /* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	482 actually has 2 significant bytes. OTOH, 0xff0001 ==
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	483 -0x00ffff, so we wouldn't need to bump it there; but we
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	484 do for 0xffff = -0x0001. To be safe without bothering to
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	485 check every case, bump it regardless. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	486 if (is_signed && numsignificantbytes < n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	487 ++numsignificantbytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	488 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	489
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	490 /* How many Python long digits do we need? We have
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	491 8*numsignificantbytes bits, and each Python long digit has SHIFT
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	492 bits, so it's the ceiling of the quotient. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	493 ndigits = (numsignificantbytes * 8 + SHIFT - 1) / SHIFT;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	494 if (ndigits > (size_t)INT_MAX)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	495 return PyErr_NoMemory();
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	496 v = _PyLong_New((int)ndigits);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	497 if (v == NULL)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	498 return NULL;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	499
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	500 /* Copy the bits over. The tricky parts are computing 2's-comp on
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	501 the fly for signed numbers, and dealing with the mismatch between
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	502 8-bit bytes and (probably) 15-bit Python digits.*/
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	503 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	504 size_t i;
18110 e21cd4135f3d _PyLong_FromByteArray: changed decl of "carry" to match "thisbyte". No Tim Peters <tim.peters@gmail.com> parents: 18109 diff changeset	505 twodigits carry = 1; /* for 2's-comp calculation */
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	506 twodigits accum = 0; /* sliding register */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	507 unsigned int accumbits = 0; /* number of bits in accum */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	508 const unsigned char* p = pstartbyte;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	509
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	510 for (i = 0; i < numsignificantbytes; ++i, p += incr) {
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	511 twodigits thisbyte = *p;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	512 /* Compute correction for 2's comp, if needed. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	513 if (is_signed) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	514 thisbyte = (0xff ^ thisbyte) + carry;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	515 carry = thisbyte >> 8;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	516 thisbyte &= 0xff;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	517 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	518 /* Because we're going LSB to MSB, thisbyte is
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	519 more significant than what's already in accum,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	520 so needs to be prepended to accum. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	521 accum \|= thisbyte << accumbits;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	522 accumbits += 8;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	523 if (accumbits >= SHIFT) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	524 /* There's enough to fill a Python digit. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	525 assert(idigit < (int)ndigits);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	526 v->ob_digit[idigit] = (digit)(accum & MASK);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	527 ++idigit;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	528 accum >>= SHIFT;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	529 accumbits -= SHIFT;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	530 assert(accumbits < SHIFT);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	531 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	532 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	533 assert(accumbits < SHIFT);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	534 if (accumbits) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	535 assert(idigit < (int)ndigits);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	536 v->ob_digit[idigit] = (digit)accum;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	537 ++idigit;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	538 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	539 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	540
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	541 v->ob_size = is_signed ? -idigit : idigit;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	542 return (PyObject *)long_normalize(v);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	543 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	544
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	545 int
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	546 _PyLong_AsByteArray(PyLongObject* v,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	547 unsigned char* bytes, size_t n,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	548 int little_endian, int is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	549 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	550 int i; /* index into v->ob_digit */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	551 Py_ssize_t ndigits; /* \|v->ob_size\| */
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	552 twodigits accum; /* sliding register */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	553 unsigned int accumbits; /* # bits in accum */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	554 int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	555 twodigits carry; /* for computing 2's-comp */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	556 size_t j; /* # bytes filled */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	557 unsigned char* p; /* pointer to next byte in bytes */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	558 int pincr; /* direction to move p */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	559
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	560 assert(v != NULL && PyLong_Check(v));
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	561
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	562 if (v->ob_size < 0) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	563 ndigits = -(v->ob_size);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	564 if (!is_signed) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	565 PyErr_SetString(PyExc_TypeError,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	566 "can't convert negative long to unsigned");
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	567 return -1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	568 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	569 do_twos_comp = 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	570 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	571 else {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	572 ndigits = v->ob_size;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	573 do_twos_comp = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	574 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	575
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	576 if (little_endian) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	577 p = bytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	578 pincr = 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	579 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	580 else {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	581 p = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	582 pincr = -1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	583 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	584
18108 8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	585 /* Copy over all the Python digits.
8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	586 It's crucial that every Python digit except for the MSD contribute
8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	587 exactly SHIFT bits to the total, so first assert that the long is
8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	588 normalized. */
8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	589 assert(ndigits == 0 \|\| v->ob_digit[ndigits - 1] != 0);
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	590 j = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	591 accum = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	592 accumbits = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	593 carry = do_twos_comp ? 1 : 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	594 for (i = 0; i < ndigits; ++i) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	595 twodigits thisdigit = v->ob_digit[i];
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	596 if (do_twos_comp) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	597 thisdigit = (thisdigit ^ MASK) + carry;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	598 carry = thisdigit >> SHIFT;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	599 thisdigit &= MASK;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	600 }
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	601 /* Because we're going LSB to MSB, thisdigit is more
a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	602 significant than what's already in accum, so needs to be
a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	603 prepended to accum. */
a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	604 accum \|= thisdigit << accumbits;
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	605 accumbits += SHIFT;
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	606
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	607 /* The most-significant digit may be (probably is) at least
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	608 partly empty. */
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	609 if (i == ndigits - 1) {
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	610 /* Count # of sign bits -- they needn't be stored,
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	611 * although for signed conversion we need later to
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	612 * make sure at least one sign bit gets stored.
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	613 * First shift conceptual sign bit to real sign bit.
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	614 */
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	615 stwodigits s = (stwodigits)(thisdigit <<
2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	616 (8*sizeof(stwodigits) - SHIFT));
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	617 unsigned int nsignbits = 0;
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	618 while ((s < 0) == do_twos_comp && nsignbits < SHIFT) {
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	619 ++nsignbits;
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	620 s <<= 1;
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	621 }
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	622 accumbits -= nsignbits;
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	623 }
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	624
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	625 /* Store as many bytes as possible. */
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	626 while (accumbits >= 8) {
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	627 if (j >= n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	628 goto Overflow;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	629 ++j;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	630 *p = (unsigned char)(accum & 0xff);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	631 p += pincr;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	632 accumbits -= 8;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	633 accum >>= 8;
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	634 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	635 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	636
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	637 /* Store the straggler (if any). */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	638 assert(accumbits < 8);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	639 assert(carry == 0); /* else do_twos_comp and every digit was 0 */
18084 bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	640 if (accumbits > 0) {
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	641 if (j >= n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	642 goto Overflow;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	643 ++j;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	644 if (do_twos_comp) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	645 /* Fill leading bits of the byte with sign bits
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	646 (appropriately pretending that the long had an
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	647 infinite supply of sign bits). */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	648 accum \|= (~(twodigits)0) << accumbits;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	649 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	650 *p = (unsigned char)(accum & 0xff);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	651 p += pincr;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	652 }
18109 be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	653 else if (j == n && n > 0 && is_signed) {
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	654 /* The main loop filled the byte array exactly, so the code
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	655 just above didn't get to ensure there's a sign bit, and the
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	656 loop below wouldn't add one either. Make sure a sign bit
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	657 exists. */
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	658 unsigned char msb = *(p - pincr);
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	659 int sign_bit_set = msb >= 0x80;
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	660 assert(accumbits == 0);
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	661 if (sign_bit_set == do_twos_comp)
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	662 return 0;
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	663 else
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	664 goto Overflow;
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	665 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	666
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	667 /* Fill remaining bytes with copies of the sign bit. */
18109 be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	668 {
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	669 unsigned char signbyte = do_twos_comp ? 0xffU : 0U;
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	670 for ( ; j < n; ++j, p += pincr)
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	671 *p = signbyte;
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	672 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	673
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	674 return 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	675
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	676 Overflow:
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	677 PyErr_SetString(PyExc_OverflowError, "long too big to convert");
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	678 return -1;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	679
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	680 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	681
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	682 double
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	683 _PyLong_AsScaledDouble(PyObject vv, int exponent)
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	684 {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	685 /* NBITS_WANTED should be > the number of bits in a double's precision,
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	686 but small enough so that 2**NBITS_WANTED is within the normal double
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	687 range. nbitsneeded is set to 1 less than that because the most-significant
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	688 Python digit contains at least 1 significant bit, but we don't want to
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	689 bother counting them (catering to the worst case cheaply).
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	690
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	691 57 is one more than VAX-D double precision; I (Tim) don't know of a double
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	692 format with more precision than that; it's 1 larger so that we add in at
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	693 least one round bit to stand in for the ignored least-significant bits.
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	694 */
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	695 #define NBITS_WANTED 57
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	696 PyLongObject *v;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	697 double x;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	698 const double multiplier = (double)(1L << SHIFT);
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	699 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	700 int sign;
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	701 int nbitsneeded;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	702
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	703 if (vv == NULL \|\| !PyLong_Check(vv)) {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	704 PyErr_BadInternalCall();
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	705 return -1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	706 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	707 v = (PyLongObject *)vv;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	708 i = v->ob_size;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	709 sign = 1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	710 if (i < 0) {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	711 sign = -1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	712 i = -(i);
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	713 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	714 else if (i == 0) {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	715 *exponent = 0;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	716 return 0.0;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	717 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	718 --i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	719 x = (double)v->ob_digit[i];
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	720 nbitsneeded = NBITS_WANTED - 1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	721 /* Invariant: i Python digits remain unaccounted for. */
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	722 while (i > 0 && nbitsneeded > 0) {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	723 --i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	724 x = x * multiplier + (double)v->ob_digit[i];
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	725 nbitsneeded -= SHIFT;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	726 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	727 /* There are i digits we didn't shift in. Pretending they're all
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	728 zeroes, the true value is x * 2*(iSHIFT). */
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	729 *exponent = i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	730 assert(x > 0.0);
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	731 return x * sign;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	732 #undef NBITS_WANTED
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	733 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	734
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4870 diff changeset	735 /* Get a C double from a long int object. */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	736
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	737 double
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	738 PyLong_AsDouble(PyObject *vv)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	739 {
36430 81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	740 int e = -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	741 double x;
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	742
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	743 if (vv == NULL \|\| !PyLong_Check(vv)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	744 PyErr_BadInternalCall();
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	745 return -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	746 }
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	747 x = _PyLong_AsScaledDouble(vv, &e);
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	748 if (x == -1.0 && PyErr_Occurred())
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	749 return -1.0;
36430 81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	750 /* 'e' initialized to -1 to silence gcc-4.0.x, but it should be
81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	751 set correctly after a successful _PyLong_AsScaledDouble() call */
81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	752 assert(e >= 0);
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	753 if (e > INT_MAX / SHIFT)
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	754 goto overflow;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	755 errno = 0;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	756 x = ldexp(x, e * SHIFT);
19717 01de0a703069 Try to recover from that glibc's ldexp apparently doesn't set errno on Tim Peters <tim.peters@gmail.com> parents: 19677 diff changeset	757 if (Py_OVERFLOWED(x))
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	758 goto overflow;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	759 return x;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	760
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	761 overflow:
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	762 PyErr_SetString(PyExc_OverflowError,
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	763 "long int too large to convert to float");
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	764 return -1.0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	765 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	766
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	767 /* Create a new long (or int) object from a C pointer */
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	768
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	769 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	770 PyLong_FromVoidPtr(void *p)
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	771 {
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	772 #if SIZEOF_VOID_P <= SIZEOF_LONG
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	773 if ((long)p < 0)
213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	774 return PyLong_FromUnsignedLong((unsigned long)p);
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	775 return PyInt_FromLong((long)p);
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	776 #else
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	777
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	778 #ifndef HAVE_LONG_LONG
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	779 # error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long"
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	780 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	781 #if SIZEOF_LONG_LONG < SIZEOF_VOID_P
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	782 # error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	783 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	784 /* optimize null pointers */
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	785 if (p == NULL)
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	786 return PyInt_FromLong(0);
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	787 return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p);
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	788
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	789 #endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	790 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	791
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	792 /* Get a C pointer from a long object (or an int object in some cases) */
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	793
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	794 void *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	795 PyLong_AsVoidPtr(PyObject *vv)
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	796 {
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	797 /* This function will allow int or long objects. If vv is neither,
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	798 then the PyLong_AsLong*() functions will raise the exception:
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	799 PyExc_SystemError, "bad argument to internal function"
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	800 */
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	801 #if SIZEOF_VOID_P <= SIZEOF_LONG
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	802 long x;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	803
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	804 if (PyInt_Check(vv))
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	805 x = PyInt_AS_LONG(vv);
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	806 else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0)
213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	807 x = PyLong_AsLong(vv);
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	808 else
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	809 x = PyLong_AsUnsignedLong(vv);
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	810 #else
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	811
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	812 #ifndef HAVE_LONG_LONG
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	813 # error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	814 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	815 #if SIZEOF_LONG_LONG < SIZEOF_VOID_P
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	816 # error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	817 #endif
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	818 PY_LONG_LONG x;
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	819
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	820 if (PyInt_Check(vv))
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	821 x = PyInt_AS_LONG(vv);
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	822 else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0)
213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	823 x = PyLong_AsLongLong(vv);
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	824 else
37568 213c4198fe23 Patch #837242: id() for large ptr should return a long. Martin v. Löwis <martin@v.loewis.de> parents: 37494 diff changeset	825 x = PyLong_AsUnsignedLongLong(vv);
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	826
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	827 #endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	828
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	829 if (x == -1 && PyErr_Occurred())
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	830 return NULL;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	831 return (void *)x;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	832 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	833
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	834 #ifdef HAVE_LONG_LONG
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	835
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	836 /* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	837 * rewritten to use the newer PyLong_{As,From}ByteArray API.
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	838 */
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	839
18121 166b7b365851 Change IS_LITTLE_ENDIAN macro -- a little faster now. Tim Peters <tim.peters@gmail.com> parents: 18115 diff changeset	840 #define IS_LITTLE_ENDIAN (int)(unsigned char)&one
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	841
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	842 /* Create a new long int object from a C PY_LONG_LONG int. */
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	843
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	844 PyObject *
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	845 PyLong_FromLongLong(PY_LONG_LONG ival)
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	846 {
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	847 PyLongObject *v;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	848 unsigned PY_LONG_LONG t; /* unsigned so >> doesn't propagate sign bit */
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	849 int ndigits = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	850 int negative = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	851
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	852 if (ival < 0) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	853 ival = -ival;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	854 negative = 1;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	855 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	856
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	857 /* Count the number of Python digits.
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	858 We used to pick 5 ("big enough for anything"), but that's a
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	859 waste of time and space given that 5*15 = 75 bits are rarely
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	860 needed. */
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	861 t = (unsigned PY_LONG_LONG)ival;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	862 while (t) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	863 ++ndigits;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	864 t >>= SHIFT;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	865 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	866 v = _PyLong_New(ndigits);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	867 if (v != NULL) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	868 digit *p = v->ob_digit;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	869 v->ob_size = negative ? -ndigits : ndigits;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	870 t = (unsigned PY_LONG_LONG)ival;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	871 while (t) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	872 *p++ = (digit)(t & MASK);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	873 t >>= SHIFT;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	874 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	875 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	876 return (PyObject *)v;
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	877 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	878
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	879 /* Create a new long int object from a C unsigned PY_LONG_LONG int. */
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	880
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	881 PyObject *
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	882 PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	883 {
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	884 PyLongObject *v;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	885 unsigned PY_LONG_LONG t;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	886 int ndigits = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	887
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	888 /* Count the number of Python digits. */
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	889 t = (unsigned PY_LONG_LONG)ival;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	890 while (t) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	891 ++ndigits;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	892 t >>= SHIFT;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	893 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	894 v = _PyLong_New(ndigits);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	895 if (v != NULL) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	896 digit *p = v->ob_digit;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	897 v->ob_size = ndigits;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	898 while (ival) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	899 *p++ = (digit)(ival & MASK);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	900 ival >>= SHIFT;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	901 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	902 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	903 return (PyObject *)v;
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	904 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	905
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	906 /* Create a new long int object from a C Py_ssize_t. */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	907
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	908 PyObject *
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	909 _PyLong_FromSsize_t(Py_ssize_t ival)
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	910 {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	911 Py_ssize_t bytes = ival;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	912 int one = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	913 return _PyLong_FromByteArray(
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	914 (unsigned char *)&bytes,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	915 SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	916 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	917
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	918 /* Create a new long int object from a C size_t. */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	919
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	920 PyObject *
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	921 _PyLong_FromSize_t(size_t ival)
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	922 {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	923 size_t bytes = ival;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	924 int one = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	925 return _PyLong_FromByteArray(
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	926 (unsigned char *)&bytes,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	927 SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	928 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	929
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	930 /* Get a C PY_LONG_LONG int from a long int object.
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	931 Return -1 and set an error if overflow occurs. */
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	932
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	933 PY_LONG_LONG
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	934 PyLong_AsLongLong(PyObject *vv)
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	935 {
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	936 PY_LONG_LONG bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	937 int one = 1;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	938 int res;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	939
20182 6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	940 if (vv == NULL) {
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	941 PyErr_BadInternalCall();
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	942 return -1;
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	943 }
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	944 if (!PyLong_Check(vv)) {
34666 4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	945 PyNumberMethods *nb;
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	946 PyObject *io;
20182 6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	947 if (PyInt_Check(vv))
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	948 return (PY_LONG_LONG)PyInt_AsLong(vv);
34666 4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	949 if ((nb = vv->ob_type->tp_as_number) == NULL \|\|
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	950 nb->nb_int == NULL) {
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	951 PyErr_SetString(PyExc_TypeError, "an integer is required");
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	952 return -1;
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	953 }
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	954 io = (*nb->nb_int) (vv);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	955 if (io == NULL)
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	956 return -1;
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	957 if (PyInt_Check(io)) {
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	958 bytes = PyInt_AsLong(io);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	959 Py_DECREF(io);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	960 return bytes;
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	961 }
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	962 if (PyLong_Check(io)) {
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	963 bytes = PyLong_AsLongLong(io);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	964 Py_DECREF(io);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	965 return bytes;
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	966 }
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	967 Py_DECREF(io);
4812f6a7f735 Revert previous checkin on getargs 'L' code. Try to convert all Martin v. Löwis <martin@v.loewis.de> parents: 33524 diff changeset	968 PyErr_SetString(PyExc_TypeError, "integer conversion failed");
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	969 return -1;
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	970 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	971
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	972 res = _PyLong_AsByteArray(
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	973 (PyLongObject )vv, (unsigned char )&bytes,
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	974 SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	975
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	976 /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */
22204 928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	977 if (res < 0)
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	978 return (PY_LONG_LONG)-1;
22204 928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	979 else
928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	980 return bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	981 }
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	982
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	983 /* Get a C unsigned PY_LONG_LONG int from a long int object.
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	984 Return -1 and set an error if overflow occurs. */
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	985
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	986 unsigned PY_LONG_LONG
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	987 PyLong_AsUnsignedLongLong(PyObject *vv)
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	988 {
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	989 unsigned PY_LONG_LONG bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	990 int one = 1;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	991 int res;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	992
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	993 if (vv == NULL \|\| !PyLong_Check(vv)) {
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	994 PyErr_BadInternalCall();
37815 20cb13bdf1f0 C++ compiler cleanup: bunch-o-casts, plus use of unsigned loop index var in a couple places Skip Montanaro <skip@pobox.com> parents: 37611 diff changeset	995 return (unsigned PY_LONG_LONG)-1;
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	996 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	997
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	998 res = _PyLong_AsByteArray(
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	999 (PyLongObject )vv, (unsigned char )&bytes,
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1000 SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1001
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	1002 /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */
22204 928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	1003 if (res < 0)
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	1004 return (unsigned PY_LONG_LONG)res;
22204 928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	1005 else
928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	1006 return bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1007 }
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1008
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1009 /* Get a C unsigned long int from a long int object, ignoring the high bits.
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1010 Returns -1 and sets an error condition if an error occurs. */
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1011
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1012 unsigned PY_LONG_LONG
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1013 PyLong_AsUnsignedLongLongMask(PyObject *vv)
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1014 {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1015 register PyLongObject *v;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1016 unsigned PY_LONG_LONG x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1017 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1018 int sign;
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1019
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1020 if (vv == NULL \|\| !PyLong_Check(vv)) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1021 PyErr_BadInternalCall();
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1022 return (unsigned long) -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1023 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1024 v = (PyLongObject *)vv;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1025 i = v->ob_size;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1026 sign = 1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1027 x = 0;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1028 if (i < 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1029 sign = -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1030 i = -i;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1031 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1032 while (--i >= 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1033 x = (x << SHIFT) + v->ob_digit[i];
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1034 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1035 return x * sign;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1036 }
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1037 #undef IS_LITTLE_ENDIAN
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1038
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1039 #endif /* HAVE_LONG_LONG */
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1040
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1041
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1042 static int
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1043 convert_binop(PyObject v, PyObject w, PyLongObject a, PyLongObject b) {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1044 if (PyLong_Check(v)) {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1045 a = (PyLongObject ) v;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1046 Py_INCREF(v);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1047 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1048 else if (PyInt_Check(v)) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1049 a = (PyLongObject ) PyLong_FromLong(PyInt_AS_LONG(v));
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1050 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1051 else {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1052 return 0;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1053 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1054 if (PyLong_Check(w)) {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1055 b = (PyLongObject ) w;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1056 Py_INCREF(w);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1057 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1058 else if (PyInt_Check(w)) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1059 b = (PyLongObject ) PyLong_FromLong(PyInt_AS_LONG(w));
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1060 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1061 else {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1062 Py_DECREF(*a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1063 return 0;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1064 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1065 return 1;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1066 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1067
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1068 #define CONVERT_BINOP(v, w, a, b) \
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1069 if (!convert_binop(v, w, a, b)) { \
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1070 Py_INCREF(Py_NotImplemented); \
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1071 return Py_NotImplemented; \
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1072 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1073
24750 c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1074 /* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n]
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1075 * is modified in place, by adding y to it. Carries are propagated as far as
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1076 * x[m-1], and the remaining carry (0 or 1) is returned.
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1077 */
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1078 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1079 v_iadd(digit x, Py_ssize_t m, digit y, Py_ssize_t n)
24750 c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1080 {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1081 int i;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1082 digit carry = 0;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1083
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1084 assert(m >= n);
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1085 for (i = 0; i < n; ++i) {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1086 carry += x[i] + y[i];
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1087 x[i] = carry & MASK;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1088 carry >>= SHIFT;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1089 assert((carry & 1) == carry);
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1090 }
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1091 for (; carry && i < m; ++i) {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1092 carry += x[i];
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1093 x[i] = carry & MASK;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1094 carry >>= SHIFT;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1095 assert((carry & 1) == carry);
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1096 }
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1097 return carry;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1098 }
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1099
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1100 /* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n]
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1101 * is modified in place, by subtracting y from it. Borrows are propagated as
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1102 * far as x[m-1], and the remaining borrow (0 or 1) is returned.
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1103 */
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1104 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1105 v_isub(digit x, Py_ssize_t m, digit y, Py_ssize_t n)
24750 c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1106 {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1107 int i;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1108 digit borrow = 0;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1109
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1110 assert(m >= n);
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1111 for (i = 0; i < n; ++i) {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1112 borrow = x[i] - y[i] - borrow;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1113 x[i] = borrow & MASK;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1114 borrow >>= SHIFT;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1115 borrow &= 1; /* keep only 1 sign bit */
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1116 }
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1117 for (; borrow && i < m; ++i) {
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1118 borrow = x[i] - borrow;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1119 x[i] = borrow & MASK;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1120 borrow >>= SHIFT;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1121 borrow &= 1;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1122 }
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1123 return borrow;
c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	1124 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1125
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1126 /* Multiply by a single digit, ignoring the sign. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1127
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1128 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1129 mul1(PyLongObject *a, wdigit n)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1130 {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1131 return muladd1(a, n, (digit)0);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1132 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1133
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1134 /* Multiply by a single digit and add a single digit, ignoring the sign. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1135
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1136 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1137 muladd1(PyLongObject *a, wdigit n, wdigit extra)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1138 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1139 Py_ssize_t size_a = ABS(a->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1140 PyLongObject *z = _PyLong_New(size_a+1);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1141 twodigits carry = extra;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1142 Py_ssize_t i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1143
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1144 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1145 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1146 for (i = 0; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1147 carry += (twodigits)a->ob_digit[i] * n;
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1148 z->ob_digit[i] = (digit) (carry & MASK);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1149 carry >>= SHIFT;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1150 }
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1151 z->ob_digit[i] = (digit) carry;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1152 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1153 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1154
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1155 /* Divide long pin, w/ size digits, by non-zero digit n, storing quotient
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1156 in pout, and returning the remainder. pin and pout point at the LSD.
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1157 It's OK for pin == pout on entry, which saves oodles of mallocs/frees in
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1158 long_format, but that should be done with great care since longs are
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1159 immutable. */
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1160
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1161 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1162 inplace_divrem1(digit pout, digit pin, Py_ssize_t size, digit n)
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1163 {
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1164 twodigits rem = 0;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1165
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1166 assert(n > 0 && n <= MASK);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1167 pin += size;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1168 pout += size;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1169 while (--size >= 0) {
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1170 digit hi;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1171 rem = (rem << SHIFT) + *--pin;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1172 *--pout = hi = (digit)(rem / n);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1173 rem -= hi * n;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1174 }
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1175 return (digit)rem;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1176 }
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1177
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1178 /* Divide a long integer by a digit, returning both the quotient
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1179 (as function result) and the remainder (through *prem).
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1180 The sign of a is ignored; n should not be zero. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1181
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1182 static PyLongObject *
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1183 divrem1(PyLongObject a, digit n, digit prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1184 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1185 const Py_ssize_t size = ABS(a->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1186 PyLongObject *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1187
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1188 assert(n > 0 && n <= MASK);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1189 z = _PyLong_New(size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1190 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1191 return NULL;
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1192 *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1193 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1194 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1195
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1196 /* Convert a long int object to a string, using a given conversion base.
406 e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1197 Return a string object.
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1198 If base is 8 or 16, add the proper prefix '0' or '0x'. */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1199
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1200 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1201 long_format(PyObject *aa, int base, int addL)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1202 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1203 register PyLongObject a = (PyLongObject )aa;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1204 PyStringObject *str;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1205 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1206 const Py_ssize_t size_a = ABS(a->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1207 char *p;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1208 int bits;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1209 char sign = '\0';
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1210
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1211 if (a == NULL \|\| !PyLong_Check(a)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1212 PyErr_BadInternalCall();
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1213 return NULL;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1214 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1215 assert(base >= 2 && base <= 36);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1216
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1217 /* Compute a rough upper bound for the length of the string */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1218 i = base;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1219 bits = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1220 while (i > 1) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1221 ++bits;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1222 i >>= 1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1223 }
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1224 i = 5 + (addL ? 1 : 0) + (size_a*SHIFT + bits-1) / bits;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1225 str = (PyStringObject ) PyString_FromStringAndSize((char )0, i);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1226 if (str == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1227 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1228 p = PyString_AS_STRING(str) + i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1229 *p = '\0';
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1230 if (addL)
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1231 *--p = 'L';
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1232 if (a->ob_size < 0)
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1233 sign = '-';
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1234
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1235 if (a->ob_size == 0) {
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1236 *--p = '0';
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1237 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1238 else if ((base & (base - 1)) == 0) {
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1239 /* JRH: special case for power-of-2 bases */
18605 0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1240 twodigits accum = 0;
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1241 int accumbits = 0; /* # of bits in accum */
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1242 int basebits = 1; /* # of bits in base-1 */
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1243 i = base;
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1244 while ((i >>= 1) > 1)
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1245 ++basebits;
18605 0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1246
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1247 for (i = 0; i < size_a; ++i) {
24919 4cb253c556b1 long_format(), long_lshift(): Someone on c.l.py is trying to boost Tim Peters <tim.peters@gmail.com> parents: 24847 diff changeset	1248 accum \|= (twodigits)a->ob_digit[i] << accumbits;
18605 0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1249 accumbits += SHIFT;
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1250 assert(accumbits >= basebits);
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1251 do {
21968 62741b25ed65 Patch #508038: Do not use a type as a variable name. Martin v. Löwis <martin@v.loewis.de> parents: 20868 diff changeset	1252 char cdigit = (char)(accum & (base - 1));
35177 27a718221e72 SF bug #1224347: int/long unification and hex() Raymond Hettinger <python@rcn.com> parents: 34931 diff changeset	1253 cdigit += (cdigit < 10) ? '0' : 'a'-10;
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1254 assert(p > PyString_AS_STRING(str));
21968 62741b25ed65 Patch #508038: Do not use a type as a variable name. Martin v. Löwis <martin@v.loewis.de> parents: 20868 diff changeset	1255 *--p = cdigit;
18605 0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1256 accumbits -= basebits;
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1257 accum >>= basebits;
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1258 } while (i < size_a-1 ? accumbits >= basebits :
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1259 accum > 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1260 }
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1261 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1262 else {
18536 b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1263 /* Not 0, and base not a power of 2. Divide repeatedly by
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1264 base, but for speed use the highest power of base that
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1265 fits in a digit. */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1266 Py_ssize_t size = size_a;
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1267 digit *pin = a->ob_digit;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1268 PyLongObject *scratch;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1269 /* powbasw <- largest power of base that fits in a digit. */
18536 b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1270 digit powbase = base; /* powbase == base ** power */
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1271 int power = 1;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1272 for (;;) {
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1273 unsigned long newpow = powbase * (unsigned long)base;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1274 if (newpow >> SHIFT) /* doesn't fit in a digit */
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1275 break;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1276 powbase = (digit)newpow;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1277 ++power;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1278 }
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1279
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1280 /* Get a scratch area for repeated division. */
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1281 scratch = _PyLong_New(size);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1282 if (scratch == NULL) {
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1283 Py_DECREF(str);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1284 return NULL;
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1285 }
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1286
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1287 /* Repeatedly divide by powbase. */
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1288 do {
18536 b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1289 int ntostore = power;
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1290 digit rem = inplace_divrem1(scratch->ob_digit,
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1291 pin, size, powbase);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1292 pin = scratch->ob_digit; /* no need to use a again */
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1293 if (pin[size - 1] == 0)
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1294 --size;
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1295 SIGCHECK({
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1296 Py_DECREF(scratch);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1297 Py_DECREF(str);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1298 return NULL;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1299 })
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1300
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1301 /* Break rem into digits. */
18593 9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1302 assert(ntostore > 0);
9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1303 do {
18536 b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1304 digit nextrem = (digit)(rem / base);
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1305 char c = (char)(rem - nextrem * base);
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1306 assert(p > PyString_AS_STRING(str));
35177 27a718221e72 SF bug #1224347: int/long unification and hex() Raymond Hettinger <python@rcn.com> parents: 34931 diff changeset	1307 c += (c < 10) ? '0' : 'a'-10;
18536 b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1308 *--p = c;
b287f2927db3 long_format(): Easy speedup for output bases that aren't a power of 2 (in Tim Peters <tim.peters@gmail.com> parents: 18500 diff changeset	1309 rem = nextrem;
18593 9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1310 --ntostore;
9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1311 /* Termination is a bit delicate: must not
9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1312 store leading zeroes, so must get out if
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1313 remaining quotient and rem are both 0. */
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1314 } while (ntostore && (size \|\| rem));
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1315 } while (size != 0);
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1316 Py_DECREF(scratch);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1317 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1318
958 a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1319 if (base == 8) {
a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1320 if (size_a != 0)
a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1321 *--p = '0';
a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1322 }
406 e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1323 else if (base == 16) {
e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1324 *--p = 'x';
e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1325 *--p = '0';
e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1326 }
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1327 else if (base != 10) {
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1328 *--p = '#';
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1329 *--p = '0' + base%10;
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1330 if (base > 10)
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1331 *--p = '0' + base/10;
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1332 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1333 if (sign)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1334 *--p = sign;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1335 if (p != PyString_AS_STRING(str)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1336 char *q = PyString_AS_STRING(str);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1337 assert(p > q);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1338 do {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1339 } while ((q++ = p++) != '\0');
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	1340 q--;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1341 _PyString_Resize((PyObject **)&str,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1342 (int) (q - PyString_AS_STRING(str)));
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1343 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1344 return (PyObject *)str;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1345 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1346
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1347 /* Table of digit values for 8-bit string -> integer conversion.
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1348 * '0' maps to 0, ..., '9' maps to 9.
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1349 * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35.
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1350 * All other indices map to 37.
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1351 * Note that when converting a base B string, a char c is a legitimate
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1352 * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B.
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1353 */
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1354 int _PyLong_DigitValue[256] = {
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1355 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1356 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1357 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1358 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1359 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1360 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1361 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1362 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1363 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1364 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1365 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1366 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1367 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1368 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1369 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1370 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1371 };
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1372
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1373 /* *str points to the first digit in a string of base `base` digits. base
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1374 * is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1375 * non-digit (which may be *str!). A normalized long is returned.
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1376 * The point to this routine is that it takes time linear in the number of
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1377 * string characters.
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1378 */
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1379 static PyLongObject *
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1380 long_from_binary_base(char **str, int base)
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1381 {
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1382 char p = str;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1383 char *start = p;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1384 int bits_per_char;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1385 Py_ssize_t n;
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1386 PyLongObject *z;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1387 twodigits accum;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1388 int bits_in_accum;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1389 digit *pdigit;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1390
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1391 assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1392 n = base;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1393 for (bits_per_char = -1; n; ++bits_per_char)
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1394 n >>= 1;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1395 /* n <- total # of bits needed, while setting p to end-of-string */
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1396 n = 0;
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1397 while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base)
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1398 ++p;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1399 *str = p;
27597 8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1400 n = (p - start) * bits_per_char;
8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1401 if (n / bits_per_char != p - start) {
8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1402 PyErr_SetString(PyExc_ValueError,
8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1403 "long string too large to convert");
8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1404 return NULL;
8e60ec88ecb8 long_from_binary_base(): Sped this a little by computing the # of bits Tim Peters <tim.peters@gmail.com> parents: 27588 diff changeset	1405 }
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1406 /* n <- # of Python digits needed, = ceiling(n/SHIFT). */
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1407 n = (n + SHIFT - 1) / SHIFT;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1408 z = _PyLong_New(n);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1409 if (z == NULL)
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1410 return NULL;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1411 /* Read string from right, and fill in long from left; i.e.,
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1412 * from least to most significant in both.
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1413 */
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1414 accum = 0;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1415 bits_in_accum = 0;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1416 pdigit = z->ob_digit;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1417 while (--p >= start) {
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1418 int k = _PyLong_DigitValue[Py_CHARMASK(*p)];
28981 815ff0ab24e7 SF patch 730594: assert from longobject.c, line 1215. Tim Peters <tim.peters@gmail.com> parents: 28920 diff changeset	1419 assert(k >= 0 && k < base);
815ff0ab24e7 SF patch 730594: assert from longobject.c, line 1215. Tim Peters <tim.peters@gmail.com> parents: 28920 diff changeset	1420 accum \|= (twodigits)(k << bits_in_accum);
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1421 bits_in_accum += bits_per_char;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1422 if (bits_in_accum >= SHIFT) {
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1423 *pdigit++ = (digit)(accum & MASK);
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1424 assert(pdigit - z->ob_digit <= (int)n);
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1425 accum >>= SHIFT;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1426 bits_in_accum -= SHIFT;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1427 assert(bits_in_accum < SHIFT);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1428 }
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1429 }
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1430 if (bits_in_accum) {
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1431 assert(bits_in_accum <= SHIFT);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1432 *pdigit++ = (digit)accum;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1433 assert(pdigit - z->ob_digit <= (int)n);
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1434 }
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1435 while (pdigit - z->ob_digit < n)
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1436 *pdigit++ = 0;
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1437 return long_normalize(z);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1438 }
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1439
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1440 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1441 PyLong_FromString(char str, char *pend, int base)
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1442 {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1443 int sign = 1;
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1444 char start, orig_str = str;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1445 PyLongObject *z;
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1446 PyObject strobj, strrepr;
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1447 Py_ssize_t slen;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1448
4587 09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	1449 if ((base != 0 && base < 2) \|\| base > 36) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1450 PyErr_SetString(PyExc_ValueError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	1451 "long() arg 2 must be >= 2 and <= 36");
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1452 return NULL;
87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1453 }
2308 14b126d0b5be use Py_CHARMASK; and don't check for neg. float to the float power here Guido van Rossum <guido@python.org> parents: 2158 diff changeset	1454 while (str != '\0' && isspace(Py_CHARMASK(str)))
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1455 str++;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1456 if (*str == '+')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1457 ++str;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1458 else if (*str == '-') {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1459 ++str;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1460 sign = -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1461 }
2308 14b126d0b5be use Py_CHARMASK; and don't check for neg. float to the float power here Guido van Rossum <guido@python.org> parents: 2158 diff changeset	1462 while (str != '\0' && isspace(Py_CHARMASK(str)))
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1463 str++;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1464 if (base == 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1465 if (str[0] != '0')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1466 base = 10;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1467 else if (str[1] == 'x' \|\| str[1] == 'X')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1468 base = 16;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1469 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1470 base = 8;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1471 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1472 if (base == 16 && str[0] == '0' && (str[1] == 'x' \|\| str[1] == 'X'))
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1473 str += 2;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1474
8533 e5d06a602469 Add check in long-to-int conversion for at least one digit. Guido van Rossum <guido@python.org> parents: 8425 diff changeset	1475 start = str;
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1476 if ((base & (base - 1)) == 0)
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1477 z = long_from_binary_base(&str, base);
7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1478 else {
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1479 /***
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1480 Binary bases can be converted in time linear in the number of digits, because
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1481 Python's representation base is binary. Other bases (including decimal!) use
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1482 the simple quadratic-time algorithm below, complicated by some speed tricks.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1483
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1484 First some math: the largest integer that can be expressed in N base-B digits
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1485 is B**N-1. Consequently, if we have an N-digit input in base B, the worst-
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1486 case number of Python digits needed to hold it is the smallest integer n s.t.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1487
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1488 BASEn-1 >= BN-1 [or, adding 1 to both sides]
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1489 BASEn >= BN [taking logs to base BASE]
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1490 n >= log(B*N)/log(BASE) = N log(B)/log(BASE)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1491
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1492 The static array log_base_BASE[base] == log(base)/log(BASE) so we can compute
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1493 this quickly. A Python long with that much space is reserved near the start,
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1494 and the result is computed into it.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1495
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1496 The input string is actually treated as being in base base**i (i.e., i digits
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1497 are processed at a time), where two more static arrays hold:
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1498
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1499 convwidth_base[base] = the largest integer i such that base**i <= BASE
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1500 convmultmax_base[base] = base ** convwidth_base[base]
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1501
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1502 The first of these is the largest i such that i consecutive input digits
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1503 must fit in a single Python digit. The second is effectively the input
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1504 base we're really using.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1505
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1506 Viewing the input as a sequence <c0, c1, ..., c_n-1> of digits in base
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1507 convmultmax_base[base], the result is "simply"
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1508
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1509 (((c0B + c1)B + c2)B + c3)B + ... ))) + c_n-1
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1510
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1511 where B = convmultmax_base[base].
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1512
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1513 Error analysis: as above, the number of Python digits `n` needed is worst-
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1514 case
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1515
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1516 n >= N * log(B)/log(BASE)
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1517
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1518 where `N` is the number of input digits in base `B`. This is computed via
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1519
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1520 size_z = (Py_ssize_t)((scan - str) * log_base_BASE[base]) + 1;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1521
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1522 below. Two numeric concerns are how much space this can waste, and whether
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1523 the computed result can be too small. To be concrete, assume BASE = 2**15,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1524 which is the default (and it's unlikely anyone changes that).
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1525
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1526 Waste isn't a problem: provided the first input digit isn't 0, the difference
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1527 between the worst-case input with N digits and the smallest input with N
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1528 digits is about a factor of B, but B is small compared to BASE so at most
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1529 one allocated Python digit can remain unused on that count. If
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1530 N*log(B)/log(BASE) is mathematically an exact integer, then truncating that
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1531 and adding 1 returns a result 1 larger than necessary. However, that can't
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1532 happen: whenever B is a power of 2, long_from_binary_base() is called
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1533 instead, and it's impossible for Bi to be an integer power of 215 when
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1534 B is not a power of 2 (i.e., it's impossible for N*log(B)/log(BASE) to be
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1535 an exact integer when B is not a power of 2, since B**i has a prime factor
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1536 other than 2 in that case, but (215)j's only prime factor is 2).
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1537
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1538 The computed result can be too small if the true value of N*log(B)/log(BASE)
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1539 is a little bit larger than an exact integer, but due to roundoff errors (in
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1540 computing log(B), log(BASE), their quotient, and/or multiplying that by N)
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1541 yields a numeric result a little less than that integer. Unfortunately, "how
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1542 close can a transcendental function get to an integer over some range?"
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1543 questions are generally theoretically intractable. Computer analysis via
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1544 continued fractions is practical: expand log(B)/log(BASE) via continued
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1545 fractions, giving a sequence i/j of "the best" rational approximations. Then
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1546 j*log(B)/log(BASE) is approximately equal to (the integer) i. This shows that
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1547 we can get very close to being in trouble, but very rarely. For example,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1548 76573 is a denominator in one of the continued-fraction approximations to
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1549 log(10)/log(2**15), and indeed:
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1550
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1551 >>> log(10)/log(2*15)76573
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1552 16958.000000654003
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1553
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1554 is very close to an integer. If we were working with IEEE single-precision,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1555 rounding errors could kill us. Finding worst cases in IEEE double-precision
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1556 requires better-than-double-precision log() functions, and Tim didn't bother.
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1557 Instead the code checks to see whether the allocated space is enough as each
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1558 new Python digit is added, and copies the whole thing to a larger long if not.
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1559 This should happen extremely rarely, and in fact I don't have a test case
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1560 that triggers it(!). Instead the code was tested by artificially allocating
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1561 just 1 digit at the start, so that the copying code was exercised for every
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1562 digit beyond the first.
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1563 ***/
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1564 register twodigits c; /* current input character */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1565 Py_ssize_t size_z;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1566 int i;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1567 int convwidth;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1568 twodigits convmultmax, convmult;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1569 digit pz, pzstop;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1570 char* scan;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1571
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1572 static double log_base_BASE[37] = {0.0e0,};
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1573 static int convwidth_base[37] = {0,};
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1574 static twodigits convmultmax_base[37] = {0,};
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1575
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1576 if (log_base_BASE[base] == 0.0) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1577 twodigits convmax = base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1578 int i = 1;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1579
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1580 log_base_BASE[base] = log((double)base) /
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1581 log((double)BASE);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1582 for (;;) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1583 twodigits next = convmax * base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1584 if (next > BASE)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1585 break;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1586 convmax = next;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1587 ++i;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1588 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1589 convmultmax_base[base] = convmax;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1590 assert(i > 0);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1591 convwidth_base[base] = i;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1592 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1593
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1594 /* Find length of the string of numeric characters. */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1595 scan = str;
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1596 while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base)
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1597 ++scan;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1598
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1599 /* Create a long object that can contain the largest possible
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1600 * integer with this base and length. Note that there's no
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1601 * need to initialize z->ob_digit -- no slot is read up before
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1602 * being stored into.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1603 */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1604 size_z = (Py_ssize_t)((scan - str) * log_base_BASE[base]) + 1;
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1605 /* Uncomment next line to test exceedingly rare copy code */
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1606 /* size_z = 1; */
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1607 assert(size_z > 0);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1608 z = _PyLong_New(size_z);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1609 if (z == NULL)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1610 return NULL;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1611 z->ob_size = 0;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1612
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1613 /* `convwidth` consecutive input digits are treated as a single
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1614 * digit in base `convmultmax`.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1615 */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1616 convwidth = convwidth_base[base];
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1617 convmultmax = convmultmax_base[base];
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1618
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1619 /* Work ;-) */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1620 while (str < scan) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1621 /* grab up to convwidth digits from the input string */
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1622 c = (digit)_PyLong_DigitValue[Py_CHARMASK(*str++)];
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1623 for (i = 1; i < convwidth && str != scan; ++i, ++str) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1624 c = (twodigits)(c * base +
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1625 _PyLong_DigitValue[Py_CHARMASK(*str)]);
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1626 assert(c < BASE);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1627 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1628
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1629 convmult = convmultmax;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1630 /* Calculate the shift only if we couldn't get
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1631 * convwidth digits.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1632 */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1633 if (i != convwidth) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1634 convmult = base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1635 for ( ; i > 1; --i)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1636 convmult *= base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1637 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1638
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1639 /* Multiply z by convmult, and add c. */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1640 pz = z->ob_digit;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1641 pzstop = pz + z->ob_size;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1642 for (; pz < pzstop; ++pz) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1643 c += (twodigits)pz convmult;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1644 *pz = (digit)(c & MASK);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1645 c >>= SHIFT;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1646 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1647 /* carry off the current end? */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1648 if (c) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1649 assert(c < BASE);
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1650 if (z->ob_size < size_z) {
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1651 *pz = (digit)c;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1652 ++z->ob_size;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1653 }
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1654 else {
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1655 PyLongObject *tmp;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1656 /* Extremely rare. Get more space. */
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1657 assert(z->ob_size == size_z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1658 tmp = _PyLong_New(size_z + 1);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1659 if (tmp == NULL) {
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1660 Py_DECREF(z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1661 return NULL;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1662 }
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1663 memcpy(tmp->ob_digit,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1664 z->ob_digit,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1665 sizeof(digit) * size_z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1666 Py_DECREF(z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1667 z = tmp;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1668 z->ob_digit[size_z] = (digit)c;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1669 ++size_z;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1670 }
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1671 }
27587 7283140d4319 long(string, base) now takes time linear in len(string) when base is a Tim Peters <tim.peters@gmail.com> parents: 27585 diff changeset	1672 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1673 }
8808 78785985a2ab Fix a potential problem in PyLong_FromString(): could fall through the Guido van Rossum <guido@python.org> parents: 8533 diff changeset	1674 if (z == NULL)
78785985a2ab Fix a potential problem in PyLong_FromString(): could fall through the Guido van Rossum <guido@python.org> parents: 8533 diff changeset	1675 return NULL;
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1676 if (str == start)
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1677 goto onError;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1678 if (sign < 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1679 z->ob_size = -(z->ob_size);
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1680 if (str == 'L' \|\| str == 'l')
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1681 str++;
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1682 while (str && isspace(Py_CHARMASK(str)))
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1683 str++;
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1684 if (*str != '\0')
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1685 goto onError;
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1686 if (pend)
87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1687 *pend = str;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1688 return (PyObject *) z;
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1689
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1690 onError:
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1691 Py_XDECREF(z);
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1692 slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1693 strobj = PyString_FromStringAndSize(orig_str, slen);
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1694 if (strobj == NULL)
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1695 return NULL;
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1696 strrepr = PyObject_Repr(strobj);
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1697 Py_DECREF(strobj);
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1698 if (strrepr == NULL)
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1699 return NULL;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1700 PyErr_Format(PyExc_ValueError,
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1701 "invalid literal for long() with base %d: %s",
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1702 base, PyString_AS_STRING(strrepr));
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1703 Py_DECREF(strrepr);
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1704 return NULL;
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1705 }
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1706
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	1707 #ifdef Py_USING_UNICODE
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1708 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1709 PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1710 {
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1711 PyObject *result;
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	1712 char buffer = (char )PyMem_MALLOC(length+1);
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1713
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1714 if (buffer == NULL)
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1715 return NULL;
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1716
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1717 if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) {
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1718 PyMem_FREE(buffer);
12248 70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1719 return NULL;
70154e2e9c89 Marc-Andre's third try at this bulk patch seems to work (except that Guido van Rossum <guido@python.org> parents: 11628 diff changeset	1720 }
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1721 result = PyLong_FromString(buffer, NULL, base);
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1722 PyMem_FREE(buffer);
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1723 return result;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1724 }
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	1725 #endif
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1726
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1727 /* forward */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1728 static PyLongObject *x_divrem
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1729 (PyLongObject , PyLongObject , PyLongObject **);
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1730 static PyObject long_pos(PyLongObject );
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1731 static int long_divrem(PyLongObject , PyLongObject ,
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1732 PyLongObject , PyLongObject );
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1733
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1734 /* Long division with remainder, top-level routine */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1735
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1736 static int
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1737 long_divrem(PyLongObject a, PyLongObject b,
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1738 PyLongObject pdiv, PyLongObject prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1739 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1740 Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1741 PyLongObject *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1742
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1743 if (size_b == 0) {
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1744 PyErr_SetString(PyExc_ZeroDivisionError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	1745 "long division or modulo by zero");
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1746 return -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1747 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1748 if (size_a < size_b \|\|
4587 09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	1749 (size_a == size_b &&
09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	1750 a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1751 /* \|a\| < \|b\|. */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1752 *pdiv = _PyLong_New(0);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1753 Py_INCREF(a);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1754 prem = (PyLongObject ) a;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1755 return 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1756 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1757 if (size_b == 1) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1758 digit rem = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1759 z = divrem1(a, b->ob_digit[0], &rem);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1760 if (z == NULL)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1761 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1762 prem = (PyLongObject ) PyLong_FromLong((long)rem);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1763 }
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1764 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1765 z = x_divrem(a, b, prem);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1766 if (z == NULL)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1767 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1768 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1769 /* Set the signs.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1770 The quotient z has the sign of a*b;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1771 the remainder r has the sign of a,
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1772 so a = bz + r. /
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1773 if ((a->ob_size < 0) != (b->ob_size < 0))
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1774 z->ob_size = -(z->ob_size);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1775 if (a->ob_size < 0 && (*prem)->ob_size != 0)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1776 (prem)->ob_size = -((prem)->ob_size);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1777 *pdiv = z;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1778 return 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1779 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1780
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1781 /* Unsigned long division with remainder -- the algorithm */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1782
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1783 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1784 x_divrem(PyLongObject v1, PyLongObject w1, PyLongObject **prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1785 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1786 Py_ssize_t size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1787 digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1788 PyLongObject *v = mul1(v1, d);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1789 PyLongObject *w = mul1(w1, d);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1790 PyLongObject *a;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1791 Py_ssize_t j, k;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1792
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1793 if (v == NULL \|\| w == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1794 Py_XDECREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1795 Py_XDECREF(w);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1796 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1797 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1798
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1799 assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1800 assert(v->ob_refcnt == 1); /* Since v will be used as accumulator! */
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1801 assert(size_w == ABS(w->ob_size)); /* That's how d was calculated */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1802
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1803 size_v = ABS(v->ob_size);
38139 f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1804 k = size_v - size_w;
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1805 a = _PyLong_New(k + 1);
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1806
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1807 for (j = size_v; a != NULL && k >= 0; --j, --k) {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1808 digit vj = (j >= size_v) ? 0 : v->ob_digit[j];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1809 twodigits q;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1810 stwodigits carry = 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1811 int i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1812
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1813 SIGCHECK({
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1814 Py_DECREF(a);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1815 a = NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1816 break;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1817 })
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1818 if (vj == w->ob_digit[size_w-1])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1819 q = MASK;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1820 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1821 q = (((twodigits)vj << SHIFT) + v->ob_digit[j-1]) /
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1822 w->ob_digit[size_w-1];
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1823
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1824 while (w->ob_digit[size_w-2]*q >
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1825 ((
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1826 ((twodigits)vj << SHIFT)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1827 + v->ob_digit[j-1]
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1828 - q*w->ob_digit[size_w-1]
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1829 ) << SHIFT)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1830 + v->ob_digit[j-2])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1831 --q;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1832
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1833 for (i = 0; i < size_w && i+k < size_v; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1834 twodigits z = w->ob_digit[i] * q;
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1835 digit zz = (digit) (z >> SHIFT);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1836 carry += v->ob_digit[i+k] - z
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1837 + ((twodigits)zz << SHIFT);
28920 00fc138d8556 Silence compiler warnings in VC 7. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28652 diff changeset	1838 v->ob_digit[i+k] = (digit)(carry & MASK);
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1839 carry = Py_ARITHMETIC_RIGHT_SHIFT(BASE_TWODIGITS_TYPE,
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1840 carry, SHIFT);
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1841 carry -= zz;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1842 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1843
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1844 if (i+k < size_v) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1845 carry += v->ob_digit[i+k];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1846 v->ob_digit[i+k] = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1847 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1848
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1849 if (carry == 0)
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1850 a->ob_digit[k] = (digit) q;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1851 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1852 assert(carry == -1);
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1853 a->ob_digit[k] = (digit) q-1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1854 carry = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1855 for (i = 0; i < size_w && i+k < size_v; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1856 carry += v->ob_digit[i+k] + w->ob_digit[i];
28920 00fc138d8556 Silence compiler warnings in VC 7. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28652 diff changeset	1857 v->ob_digit[i+k] = (digit)(carry & MASK);
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1858 carry = Py_ARITHMETIC_RIGHT_SHIFT(
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1859 BASE_TWODIGITS_TYPE,
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1860 carry, SHIFT);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1861 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1862 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1863 } /* for j, k */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1864
2111 30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1865 if (a == NULL)
30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1866 *prem = NULL;
30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1867 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1868 a = long_normalize(a);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1869 *prem = divrem1(v, d, &d);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1870 /* d receives the (unused) remainder */
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1871 if (*prem == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1872 Py_DECREF(a);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1873 a = NULL;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1874 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1875 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1876 Py_DECREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1877 Py_DECREF(w);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1878 return a;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1879 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1880
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1881 /* Methods */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1882
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1883 static void
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1884 long_dealloc(PyObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1885 {
20277 2983b54256c7 Enable GC for new-style instances. This touches lots of files, since Guido van Rossum <guido@python.org> parents: 20182 diff changeset	1886 v->ob_type->tp_free(v);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1887 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1888
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1889 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1890 long_repr(PyObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1891 {
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1892 return long_format(v, 10, 1);
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1893 }
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1894
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1895 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1896 long_str(PyObject *v)
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1897 {
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1898 return long_format(v, 10, 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1899 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1900
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1901 static int
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1902 long_compare(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1903 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1904 Py_ssize_t sign;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1905
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1906 if (a->ob_size != b->ob_size) {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	1907 if (ABS(a->ob_size) == 0 && ABS(b->ob_size) == 0)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1908 sign = 0;
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1909 else
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1910 sign = a->ob_size - b->ob_size;
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1911 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1912 else {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1913 Py_ssize_t i = ABS(a->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1914 while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1915 ;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1916 if (i < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1917 sign = 0;
1191 38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1918 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1919 sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
1191 38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1920 if (a->ob_size < 0)
38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1921 sign = -sign;
38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1922 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1923 }
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1924 return sign < 0 ? -1 : sign > 0 ? 1 : 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1925 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1926
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1927 static long
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1928 long_hash(PyLongObject *v)
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1929 {
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1930 long x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1931 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1932 int sign;
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1933
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1934 /* This is designed so that Python ints and longs with the
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1935 same value hash to the same value, otherwise comparisons
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1936 of mapping keys will turn out weird */
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1937 i = v->ob_size;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1938 sign = 1;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1939 x = 0;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1940 if (i < 0) {
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1941 sign = -1;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1942 i = -(i);
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1943 }
28032 53bef20f84cc Fix SF bug #689659, 64-bit int and long hash keys incompatible Neal Norwitz <nnorwitz@gmail.com> parents: 27639 diff changeset	1944 #define LONG_BIT_SHIFT (8*sizeof(long) - SHIFT)
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1945 while (--i >= 0) {
28032 53bef20f84cc Fix SF bug #689659, 64-bit int and long hash keys incompatible Neal Norwitz <nnorwitz@gmail.com> parents: 27639 diff changeset	1946 /* Force a native long #-bits (32 or 64) circular shift */
53bef20f84cc Fix SF bug #689659, 64-bit int and long hash keys incompatible Neal Norwitz <nnorwitz@gmail.com> parents: 27639 diff changeset	1947 x = ((x << SHIFT) & ~MASK) \| ((x >> LONG_BIT_SHIFT) & MASK);
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1948 x += v->ob_digit[i];
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1949 }
28032 53bef20f84cc Fix SF bug #689659, 64-bit int and long hash keys incompatible Neal Norwitz <nnorwitz@gmail.com> parents: 27639 diff changeset	1950 #undef LONG_BIT_SHIFT
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1951 x = x * sign;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1952 if (x == -1)
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1953 x = -2;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1954 return x;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1955 }
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1956
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1957
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1958 /* Add the absolute values of two long integers. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1959
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1960 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1961 x_add(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1962 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1963 Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1964 PyLongObject *z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1965 int i;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1966 digit carry = 0;
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	1967
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1968 /* Ensure a is the larger of the two: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1969 if (size_a < size_b) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1970 { PyLongObject *temp = a; a = b; b = temp; }
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1971 { Py_ssize_t size_temp = size_a;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1972 size_a = size_b;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1973 size_b = size_temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1974 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1975 z = _PyLong_New(size_a+1);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1976 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1977 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1978 for (i = 0; i < size_b; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1979 carry += a->ob_digit[i] + b->ob_digit[i];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1980 z->ob_digit[i] = carry & MASK;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1981 carry >>= SHIFT;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1982 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1983 for (; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1984 carry += a->ob_digit[i];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1985 z->ob_digit[i] = carry & MASK;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1986 carry >>= SHIFT;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1987 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1988 z->ob_digit[i] = carry;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1989 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1990 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1991
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1992 /* Subtract the absolute values of two integers. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1993
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1994 static PyLongObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1995 x_sub(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1996 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1997 Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1998 PyLongObject *z;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1999 Py_ssize_t i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2000 int sign = 1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2001 digit borrow = 0;
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2002
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2003 /* Ensure a is the larger of the two: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2004 if (size_a < size_b) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2005 sign = -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2006 { PyLongObject *temp = a; a = b; b = temp; }
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2007 { Py_ssize_t size_temp = size_a;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2008 size_a = size_b;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2009 size_b = size_temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2010 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2011 else if (size_a == size_b) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2012 /* Find highest digit where a and b differ: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2013 i = size_a;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2014 while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2015 ;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2016 if (i < 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2017 return _PyLong_New(0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2018 if (a->ob_digit[i] < b->ob_digit[i]) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2019 sign = -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2020 { PyLongObject *temp = a; a = b; b = temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2021 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2022 size_a = size_b = i+1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2023 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2024 z = _PyLong_New(size_a);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2025 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2026 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2027 for (i = 0; i < size_b; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2028 /* The following assumes unsigned arithmetic
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2029 works module 2*N for some N>SHIFT. /
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	2030 borrow = a->ob_digit[i] - b->ob_digit[i] - borrow;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2031 z->ob_digit[i] = borrow & MASK;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2032 borrow >>= SHIFT;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2033 borrow &= 1; /* Keep only one sign bit */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2034 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2035 for (; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2036 borrow = a->ob_digit[i] - borrow;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2037 z->ob_digit[i] = borrow & MASK;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2038 borrow >>= SHIFT;
13420 d3f1eefdcb3a The tail end of x_sub implicitly assumed that an unsigned short Tim Peters <tim.peters@gmail.com> parents: 13418 diff changeset	2039 borrow &= 1; /* Keep only one sign bit */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2040 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2041 assert(borrow == 0);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2042 if (sign < 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2043 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2044 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2045 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2046
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2047 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2048 long_add(PyLongObject v, PyLongObject w)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2049 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2050 PyLongObject a, b, *z;
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2051
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2052 CONVERT_BINOP((PyObject )v, (PyObject )w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2053
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2054 if (a->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2055 if (b->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2056 z = x_add(a, b);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2057 if (z != NULL && z->ob_size != 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2058 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2059 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2060 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2061 z = x_sub(b, a);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2062 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2063 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2064 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2065 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2066 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2067 z = x_add(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2068 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2069 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2070 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2071 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2072 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2073
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2074 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2075 long_sub(PyLongObject v, PyLongObject w)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2076 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2077 PyLongObject a, b, *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2078
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2079 CONVERT_BINOP((PyObject )v, (PyObject )w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2080
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2081 if (a->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2082 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2083 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2084 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2085 z = x_add(a, b);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2086 if (z != NULL && z->ob_size != 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2087 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2088 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2089 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2090 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2091 z = x_add(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2092 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2093 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2094 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2095 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2096 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2097 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2098 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2099
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2100 /* Grade school multiplication, ignoring the signs.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2101 * Returns the absolute value of the product, or NULL if error.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2102 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2103 static PyLongObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2104 x_mul(PyLongObject a, PyLongObject b)
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2105 {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2106 PyLongObject *z;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2107 Py_ssize_t size_a = ABS(a->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2108 Py_ssize_t size_b = ABS(b->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2109 Py_ssize_t i;
19925 df409844b659 A fix for SF bug #461546 (bug in long_mul). Guido van Rossum <guido@python.org> parents: 19897 diff changeset	2110
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2111 z = _PyLong_New(size_a + size_b);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2112 if (z == NULL)
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2113 return NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2114
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2115 memset(z->ob_digit, 0, z->ob_size * sizeof(digit));
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2116 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2117 /* Efficient squaring per HAC, Algorithm 14.16:
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2118 * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2119 * Gives slightly less than a 2x speedup when a == b,
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2120 * via exploiting that each entry in the multiplication
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2121 * pyramid appears twice (except for the size_a squares).
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2122 */
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2123 for (i = 0; i < size_a; ++i) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2124 twodigits carry;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2125 twodigits f = a->ob_digit[i];
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2126 digit *pz = z->ob_digit + (i << 1);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2127 digit *pa = a->ob_digit + i + 1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2128 digit *paend = a->ob_digit + size_a;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2129
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2130 SIGCHECK({
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2131 Py_DECREF(z);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2132 return NULL;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2133 })
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2134
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2135 carry = pz + f f;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2136 *pz++ = (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2137 carry >>= SHIFT;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2138 assert(carry <= MASK);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2139
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2140 /* Now f is added in twice in each column of the
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2141 * pyramid it appears. Same as adding f<<1 once.
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2142 */
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2143 f <<= 1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2144 while (pa < paend) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2145 carry += pz + pa++ * f;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2146 *pz++ = (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2147 carry >>= SHIFT;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2148 assert(carry <= (MASK << 1));
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2149 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2150 if (carry) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2151 carry += *pz;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2152 *pz++ = (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2153 carry >>= SHIFT;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2154 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2155 if (carry)
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2156 *pz += (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2157 assert((carry >> SHIFT) == 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2158 }
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2159 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2160 else { /* a is not the same as b -- gradeschool long mult */
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2161 for (i = 0; i < size_a; ++i) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2162 twodigits carry = 0;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2163 twodigits f = a->ob_digit[i];
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2164 digit *pz = z->ob_digit + i;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2165 digit *pb = b->ob_digit;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2166 digit *pbend = b->ob_digit + size_b;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2167
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2168 SIGCHECK({
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2169 Py_DECREF(z);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2170 return NULL;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2171 })
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2172
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2173 while (pb < pbend) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2174 carry += pz + pb++ * f;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2175 *pz++ = (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2176 carry >>= SHIFT;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2177 assert(carry <= MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2178 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2179 if (carry)
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2180 *pz += (digit)(carry & MASK);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2181 assert((carry >> SHIFT) == 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2182 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2183 }
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2184 return long_normalize(z);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2185 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2186
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2187 /* A helper for Karatsuba multiplication (k_mul).
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2188 Takes a long "n" and an integer "size" representing the place to
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2189 split, and sets low and high such that abs(n) == (high << size) + low,
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2190 viewing the shift as being by digits. The sign bit is ignored, and
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2191 the return values are >= 0.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2192 Returns 0 on success, -1 on failure.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2193 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2194 static int
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2195 kmul_split(PyLongObject n, Py_ssize_t size, PyLongObject high, PyLongObject *low)
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2196 {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2197 PyLongObject hi, lo;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2198 Py_ssize_t size_lo, size_hi;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2199 const Py_ssize_t size_n = ABS(n->ob_size);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2200
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2201 size_lo = MIN(size_n, size);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2202 size_hi = size_n - size_lo;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2203
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2204 if ((hi = _PyLong_New(size_hi)) == NULL)
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2205 return -1;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2206 if ((lo = _PyLong_New(size_lo)) == NULL) {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2207 Py_DECREF(hi);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2208 return -1;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2209 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2210
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2211 memcpy(lo->ob_digit, n->ob_digit, size_lo * sizeof(digit));
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2212 memcpy(hi->ob_digit, n->ob_digit + size_lo, size_hi * sizeof(digit));
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2213
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2214 *high = long_normalize(hi);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2215 *low = long_normalize(lo);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2216 return 0;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2217 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2218
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2219 static PyLongObject k_lopsided_mul(PyLongObject a, PyLongObject *b);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2220
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2221 /* Karatsuba multiplication. Ignores the input signs, and returns the
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2222 * absolute value of the product (or NULL if error).
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2223 * See Knuth Vol. 2 Chapter 4.3.3 (Pp. 294-295).
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2224 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2225 static PyLongObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2226 k_mul(PyLongObject a, PyLongObject b)
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2227 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2228 Py_ssize_t asize = ABS(a->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2229 Py_ssize_t bsize = ABS(b->ob_size);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2230 PyLongObject *ah = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2231 PyLongObject *al = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2232 PyLongObject *bh = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2233 PyLongObject *bl = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2234 PyLongObject *ret = NULL;
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2235 PyLongObject t1, t2, *t3;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2236 Py_ssize_t shift; /* the number of digits we split off */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2237 Py_ssize_t i;
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2238
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2239 /* (ahX+al)(bhX+bl) = ahbhXX + (ahbl + albh)X + al*bl
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2240 * Let k = (ah+al)(bh+bl) = ahbl + albh + ahbh + al*bl
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2241 * Then the original product is
24746 49169d00ab18 k_mul(): Repaired typo in comment. Tim Peters <tim.peters@gmail.com> parents: 24745 diff changeset	2242 * ahbhXX + (k - ahbh - albl)X + al*bl
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2243 * By picking X to be a power of 2, "*X" is just shifting, and it's
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2244 * been reduced to 3 multiplies on numbers half the size.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2245 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2246
24747 19e010f792a3 k_mul(): Repaired another typo in another comment. Tim Peters <tim.peters@gmail.com> parents: 24746 diff changeset	2247 /* We want to split based on the larger number; fiddle so that b
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2248 * is largest.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2249 */
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2250 if (asize > bsize) {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2251 t1 = a;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2252 a = b;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2253 b = t1;
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2254
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2255 i = asize;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2256 asize = bsize;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2257 bsize = i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2258 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2259
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2260 /* Use gradeschool math when either number is too small. */
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2261 i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2262 if (asize <= i) {
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2263 if (asize == 0)
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2264 return _PyLong_New(0);
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2265 else
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2266 return x_mul(a, b);
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2267 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2268
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2269 /* If a is small compared to b, splitting on b gives a degenerate
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2270 * case with ah==0, and Karatsuba may be (even much) less efficient
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2271 * than "grade school" then. However, we can still win, by viewing
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2272 * b as a string of "big digits", each of width a->ob_size. That
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2273 * leads to a sequence of balanced calls to k_mul.
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2274 */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2275 if (2 * asize <= bsize)
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2276 return k_lopsided_mul(a, b);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2277
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2278 /* Split a & b into hi & lo pieces. */
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2279 shift = bsize >> 1;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2280 if (kmul_split(a, shift, &ah, &al) < 0) goto fail;
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2281 assert(ah->ob_size > 0); /* the split isn't degenerate */
dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2282
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2283 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2284 bh = ah;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2285 bl = al;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2286 Py_INCREF(bh);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2287 Py_INCREF(bl);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2288 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2289 else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2290
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2291 /* The plan:
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2292 * 1. Allocate result space (asize + bsize digits: that's always
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2293 * enough).
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2294 * 2. Compute ahbh, and copy into result at 2shift.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2295 * 3. Compute al*bl, and copy into result at 0. Note that this
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2296 * can't overlap with #2.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2297 * 4. Subtract al*bl from the result, starting at shift. This may
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2298 * underflow (borrow out of the high digit), but we don't care:
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2299 * we're effectively doing unsigned arithmetic mod
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2300 * BASE*(sizea + sizeb), and so long as the final* result fits,
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2301 * borrows and carries out of the high digit can be ignored.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2302 * 5. Subtract ah*bh from the result, starting at shift.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2303 * 6. Compute (ah+al)*(bh+bl), and add it into the result starting
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2304 * at shift.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2305 */
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2306
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2307 /* 1. Allocate result space. */
24764 f0bd5cd4b170 k_mul(): Heh -- I checked in two fixes for the last problem. Only keep Tim Peters <tim.peters@gmail.com> parents: 24763 diff changeset	2308 ret = _PyLong_New(asize + bsize);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2309 if (ret == NULL) goto fail;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2310 #ifdef Py_DEBUG
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2311 /* Fill with trash, to catch reference to uninitialized digits. */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2312 memset(ret->ob_digit, 0xDF, ret->ob_size * sizeof(digit));
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2313 #endif
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2314
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2315 /* 2. t1 <- ahbh, and copy into high digits of result. /
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2316 if ((t1 = k_mul(ah, bh)) == NULL) goto fail;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2317 assert(t1->ob_size >= 0);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2318 assert(2*shift + t1->ob_size <= ret->ob_size);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2319 memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2320 t1->ob_size * sizeof(digit));
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2321
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2322 /* Zero-out the digits higher than the ahbh copy. /
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2323 i = ret->ob_size - 2*shift - t1->ob_size;
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2324 if (i)
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2325 memset(ret->ob_digit + 2*shift + t1->ob_size, 0,
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2326 i * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2327
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2328 /* 3. t2 <- albl, and copy into the low digits. /
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2329 if ((t2 = k_mul(al, bl)) == NULL) {
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2330 Py_DECREF(t1);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2331 goto fail;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2332 }
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2333 assert(t2->ob_size >= 0);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2334 assert(t2->ob_size <= 2shift); / no overlap with high digits */
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2335 memcpy(ret->ob_digit, t2->ob_digit, t2->ob_size * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2336
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2337 /* Zero out remaining digits. */
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2338 i = 2shift - t2->ob_size; / number of uninitialized digits */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2339 if (i)
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2340 memset(ret->ob_digit + t2->ob_size, 0, i * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2341
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2342 /* 4 & 5. Subtract ahbh (t1) and albl (t2). We do al*bl first
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2343 * because it's fresher in cache.
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2344 */
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2345 i = ret->ob_size - shift; /* # digits after shift */
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2346 (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, t2->ob_size);
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2347 Py_DECREF(t2);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2348
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2349 (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, t1->ob_size);
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2350 Py_DECREF(t1);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2351
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2352 /* 6. t3 <- (ah+al)(bh+bl), and add into result. */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2353 if ((t1 = x_add(ah, al)) == NULL) goto fail;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2354 Py_DECREF(ah);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2355 Py_DECREF(al);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2356 ah = al = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2357
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2358 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2359 t2 = t1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2360 Py_INCREF(t2);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2361 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2362 else if ((t2 = x_add(bh, bl)) == NULL) {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2363 Py_DECREF(t1);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2364 goto fail;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2365 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2366 Py_DECREF(bh);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2367 Py_DECREF(bl);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2368 bh = bl = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2369
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2370 t3 = k_mul(t1, t2);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2371 Py_DECREF(t1);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2372 Py_DECREF(t2);
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2373 if (t3 == NULL) goto fail;
24765 4cafd9dbc8b4 k_mul(): Moved an assert down. In a debug build, interrupting a Tim Peters <tim.peters@gmail.com> parents: 24764 diff changeset	2374 assert(t3->ob_size >= 0);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2375
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2376 /* Add t3. It's not obvious why we can't run out of room here.
dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2377 * See the (*) comment after this function.
24763 5ed7c977d2a9 k_mul(): White-box testing turned up that (ah+al)(bh+bl) can, in rare Tim Peters <tim.peters@gmail.com>* parents: 24760 diff changeset	2378 */
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2379 (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, t3->ob_size);
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2380 Py_DECREF(t3);
24750 c248bee52dc6 Introduced helper functions v_iadd and v_isub, for in-place digit-vector Tim Peters <tim.peters@gmail.com> parents: 24747 diff changeset	2381
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2382 return long_normalize(ret);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2383
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2384 fail:
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2385 Py_XDECREF(ret);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2386 Py_XDECREF(ah);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2387 Py_XDECREF(al);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2388 Py_XDECREF(bh);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2389 Py_XDECREF(bl);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2390 return NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2391 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2392
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2393 /* (*) Why adding t3 can't "run out of room" above.
dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2394
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2395 Let f(x) mean the floor of x and c(x) mean the ceiling of x. Some facts
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2396 to start with:
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2397
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2398 1. For any integer i, i = c(i/2) + f(i/2). In particular,
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2399 bsize = c(bsize/2) + f(bsize/2).
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2400 2. shift = f(bsize/2)
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2401 3. asize <= bsize
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2402 4. Since we call k_lopsided_mul if asize2 <= bsize, asize2 > bsize in this
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2403 routine, so asize > bsize/2 >= f(bsize/2) in this routine.
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2404
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2405 We allocated asize + bsize result digits, and add t3 into them at an offset
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2406 of shift. This leaves asize+bsize-shift allocated digit positions for t3
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2407 to fit into, = (by #1 and #2) asize + f(bsize/2) + c(bsize/2) - f(bsize/2) =
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2408 asize + c(bsize/2) available digit positions.
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2409
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2410 bh has c(bsize/2) digits, and bl at most f(size/2) digits. So bh+hl has
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2411 at most c(bsize/2) digits + 1 bit.
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2412
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2413 If asize == bsize, ah has c(bsize/2) digits, else ah has at most f(bsize/2)
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2414 digits, and al has at most f(bsize/2) digits in any case. So ah+al has at
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2415 most (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 1 bit.
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2416
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2417 The product (ah+al)*(bh+bl) therefore has at most
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2418
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2419 c(bsize/2) + (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2420
24846 10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2421 and we have asize + c(bsize/2) available digit positions. We need to show
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2422 this is always enough. An instance of c(bsize/2) cancels out in both, so
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2423 the question reduces to whether asize digits is enough to hold
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2424 (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits. If asize < bsize,
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2425 then we're asking whether asize digits >= f(bsize/2) digits + 2 bits. By #4,
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2426 asize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2427 digit is enough to hold 2 bits. This is so since SHIFT=15 >= 2. If
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2428 asize == bsize, then we're asking whether bsize digits is enough to hold
24847 873f12f68e3b Illustrating by example one good reason not to trust a proof <wink>. Tim Peters <tim.peters@gmail.com> parents: 24846 diff changeset	2429 c(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits
873f12f68e3b Illustrating by example one good reason not to trust a proof <wink>. Tim Peters <tim.peters@gmail.com> parents: 24846 diff changeset	2430 is enough to hold 2 bits. This is so if bsize >= 2, which holds because
873f12f68e3b Illustrating by example one good reason not to trust a proof <wink>. Tim Peters <tim.peters@gmail.com> parents: 24846 diff changeset	2431 bsize >= KARATSUBA_CUTOFF >= 2.
24821 ae9c9f90b4b0 k_mul() comments: Explained why there's always enough room to subtract Tim Peters <tim.peters@gmail.com> parents: 24792 diff changeset	2432
24824 7c91d303c563 k_mul() comments: Simplified the simplified explanation of why ahbh and Tim Peters <tim.peters@gmail.com>* parents: 24821 diff changeset	2433 Note that since there's always enough room for (ah+al)*(bh+bl), and that's
7c91d303c563 k_mul() comments: Simplified the simplified explanation of why ahbh and Tim Peters <tim.peters@gmail.com>* parents: 24821 diff changeset	2434 clearly >= each of ahbh and albl, there's always enough room to subtract
7c91d303c563 k_mul() comments: Simplified the simplified explanation of why ahbh and Tim Peters <tim.peters@gmail.com>* parents: 24821 diff changeset	2435 ahbh and albl too.
24791 dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2436 */
dbf4cc560898 k_mul(): The fix for (ah+al)(bh+bl) spilling 1 bit beyond the allocated Tim Peters <tim.peters@gmail.com>* parents: 24777 diff changeset	2437
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2438 /* b has at least twice the digits of a, and a is big enough that Karatsuba
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2439 * would pay off if the inputs had balanced sizes. View b as a sequence
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2440 * of slices, each with a->ob_size digits, and multiply the slices by a,
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2441 * one at a time. This gives k_mul balanced inputs to work with, and is
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2442 * also cache-friendly (we compute one double-width slice of the result
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2443 * at a time, then move on, never bactracking except for the helpful
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2444 * single-width slice overlap between successive partial sums).
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2445 */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2446 static PyLongObject *
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2447 k_lopsided_mul(PyLongObject a, PyLongObject b)
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2448 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2449 const Py_ssize_t asize = ABS(a->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2450 Py_ssize_t bsize = ABS(b->ob_size);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2451 Py_ssize_t nbdone; /* # of b digits already multiplied */
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2452 PyLongObject *ret;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2453 PyLongObject *bslice = NULL;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2454
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2455 assert(asize > KARATSUBA_CUTOFF);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2456 assert(2 * asize <= bsize);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2457
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2458 /* Allocate result space, and zero it out. */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2459 ret = _PyLong_New(asize + bsize);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2460 if (ret == NULL)
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2461 return NULL;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2462 memset(ret->ob_digit, 0, ret->ob_size * sizeof(digit));
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2463
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2464 /* Successive slices of b are copied into bslice. */
24775 6c6df69236b1 k_lopsided_mul(): This allocated more space for bslice than necessary. Tim Peters <tim.peters@gmail.com> parents: 24773 diff changeset	2465 bslice = _PyLong_New(asize);
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2466 if (bslice == NULL)
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2467 goto fail;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2468
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2469 nbdone = 0;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2470 while (bsize > 0) {
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2471 PyLongObject *product;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2472 const Py_ssize_t nbtouse = MIN(bsize, asize);
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2473
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2474 /* Multiply the next slice of b by a. */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2475 memcpy(bslice->ob_digit, b->ob_digit + nbdone,
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2476 nbtouse * sizeof(digit));
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2477 bslice->ob_size = nbtouse;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2478 product = k_mul(a, bslice);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2479 if (product == NULL)
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2480 goto fail;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2481
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2482 /* Add into result. */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2483 (void)v_iadd(ret->ob_digit + nbdone, ret->ob_size - nbdone,
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2484 product->ob_digit, product->ob_size);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2485 Py_DECREF(product);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2486
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2487 bsize -= nbtouse;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2488 nbdone += nbtouse;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2489 }
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2490
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2491 Py_DECREF(bslice);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2492 return long_normalize(ret);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2493
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2494 fail:
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2495 Py_DECREF(ret);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2496 Py_XDECREF(bslice);
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2497 return NULL;
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2498 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2499
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2500 static PyObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2501 long_mul(PyLongObject v, PyLongObject w)
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2502 {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2503 PyLongObject a, b, *z;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2504
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2505 if (!convert_binop((PyObject )v, (PyObject )w, &a, &b)) {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2506 Py_INCREF(Py_NotImplemented);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2507 return Py_NotImplemented;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2508 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2509
24759 3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2510 z = k_mul(a, b);
24845 6939d72182e6 long_mul(): Simplified exit code. In particular, k_mul() returns a Tim Peters <tim.peters@gmail.com> parents: 24824 diff changeset	2511 /* Negate if exactly one of the inputs is negative. */
6939d72182e6 long_mul(): Simplified exit code. In particular, k_mul() returns a Tim Peters <tim.peters@gmail.com> parents: 24824 diff changeset	2512 if (((a->ob_size ^ b->ob_size) < 0) && z)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2513 z->ob_size = -(z->ob_size);
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2514 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2515 Py_DECREF(b);
24845 6939d72182e6 long_mul(): Simplified exit code. In particular, k_mul() returns a Tim Peters <tim.peters@gmail.com> parents: 24824 diff changeset	2516 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2517 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2518
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2519 /* The / and % operators are now defined in terms of divmod().
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2520 The expression a mod b has the value a - b*floor(a/b).
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2521 The long_divrem function gives the remainder after division of
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2522 \|a\| by \|b\|, with the sign of a. This is also expressed
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2523 as a - b*trunc(a/b), if trunc truncates towards zero.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2524 Some examples:
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2525 a b a rem b a mod b
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2526 13 10 3 3
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2527 -13 10 -3 7
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2528 13 -10 3 -7
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2529 -13 -10 -3 -3
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2530 So, to get from rem to mod, we have to add b if a and b
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2531 have different signs. We then subtract one from the 'div'
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2532 part of the outcome to keep the invariant intact. */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2533
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2534 /* Compute
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2535 * pdiv, pmod = divmod(v, w)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2536 * NULL can be passed for pdiv or pmod, in which case that part of
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2537 * the result is simply thrown away. The caller owns a reference to
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2538 * each of these it requests (does not pass NULL for).
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2539 */
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2540 static int
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2541 l_divmod(PyLongObject v, PyLongObject w,
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2542 PyLongObject pdiv, PyLongObject pmod)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2543 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2544 PyLongObject div, mod;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2545
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2546 if (long_divrem(v, w, &div, &mod) < 0)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2547 return -1;
4587 09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	2548 if ((mod->ob_size < 0 && w->ob_size > 0) \|\|
09d94e9eb101 Fix newlongobject so it will work for 64-bit as well as 32-bit hardware Guido van Rossum <guido@python.org> parents: 4503 diff changeset	2549 (mod->ob_size > 0 && w->ob_size < 0)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2550 PyLongObject *temp;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2551 PyLongObject *one;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2552 temp = (PyLongObject *) long_add(mod, w);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2553 Py_DECREF(mod);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2554 mod = temp;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2555 if (mod == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2556 Py_DECREF(div);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2557 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2558 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2559 one = (PyLongObject *) PyLong_FromLong(1L);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2560 if (one == NULL \|\|
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2561 (temp = (PyLongObject *) long_sub(div, one)) == NULL) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2562 Py_DECREF(mod);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2563 Py_DECREF(div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2564 Py_XDECREF(one);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2565 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2566 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2567 Py_DECREF(one);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2568 Py_DECREF(div);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2569 div = temp;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2570 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2571 if (pdiv != NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2572 *pdiv = div;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2573 else
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2574 Py_DECREF(div);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2575
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2576 if (pmod != NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2577 *pmod = mod;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2578 else
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2579 Py_DECREF(mod);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2580
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2581 return 0;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2582 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2583
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2584 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2585 long_div(PyObject v, PyObject w)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2586 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2587 PyLongObject a, b, *div;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2588
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2589 CONVERT_BINOP(v, w, &a, &b);
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2590 if (l_divmod(a, b, &div, NULL) < 0)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2591 div = NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2592 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2593 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2594 return (PyObject *)div;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2595 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2596
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2597 static PyObject *
19633 c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2598 long_classic_div(PyObject v, PyObject w)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2599 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2600 PyLongObject a, b, *div;
19633 c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2601
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2602 CONVERT_BINOP(v, w, &a, &b);
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2603 if (Py_DivisionWarningFlag &&
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2604 PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0)
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2605 div = NULL;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2606 else if (l_divmod(a, b, &div, NULL) < 0)
19633 c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2607 div = NULL;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2608 Py_DECREF(a);
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2609 Py_DECREF(b);
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2610 return (PyObject *)div;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2611 }
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2612
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2613 static PyObject *
19675 685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2614 long_true_divide(PyObject v, PyObject w)
685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2615 {
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2616 PyLongObject a, b;
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2617 double ad, bd;
36430 81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	2618 int failed, aexp = -1, bexp = -1;
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2619
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2620 CONVERT_BINOP(v, w, &a, &b);
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2621 ad = _PyLong_AsScaledDouble((PyObject *)a, &aexp);
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2622 bd = _PyLong_AsScaledDouble((PyObject *)b, &bexp);
20868 2d9e41a72a68 long_true_divide(): decref its converted arguments. test_long_future.py Tim Peters <tim.peters@gmail.com> parents: 20277 diff changeset	2623 failed = (ad == -1.0 \|\| bd == -1.0) && PyErr_Occurred();
2d9e41a72a68 long_true_divide(): decref its converted arguments. test_long_future.py Tim Peters <tim.peters@gmail.com> parents: 20277 diff changeset	2624 Py_DECREF(a);
2d9e41a72a68 long_true_divide(): decref its converted arguments. test_long_future.py Tim Peters <tim.peters@gmail.com> parents: 20277 diff changeset	2625 Py_DECREF(b);
2d9e41a72a68 long_true_divide(): decref its converted arguments. test_long_future.py Tim Peters <tim.peters@gmail.com> parents: 20277 diff changeset	2626 if (failed)
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2627 return NULL;
36430 81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	2628 /* 'aexp' and 'bexp' were initialized to -1 to silence gcc-4.0.x,
81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	2629 but should really be set correctly after sucessful calls to
81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	2630 _PyLong_AsScaledDouble() */
81942fc9a20d As discussed on python-dev, silence three gcc-4.0.x warnings, using assert() Thomas Wouters <thomas@python.org> parents: 35999 diff changeset	2631 assert(aexp >= 0 && bexp >= 0);
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2632
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2633 if (bd == 0.0) {
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2634 PyErr_SetString(PyExc_ZeroDivisionError,
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2635 "long division or modulo by zero");
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2636 return NULL;
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2637 }
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2638
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2639 /* True value is very close to ad/bd * 2*(SHIFT(aexp-bexp)) */
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2640 ad /= bd; /* overflow/underflow impossible here */
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2641 aexp -= bexp;
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2642 if (aexp > INT_MAX / SHIFT)
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2643 goto overflow;
19787 f814ea6bb667 long_true_divide: reliably force underflow to 0 when the denominator Tim Peters <tim.peters@gmail.com> parents: 19719 diff changeset	2644 else if (aexp < -(INT_MAX / SHIFT))
f814ea6bb667 long_true_divide: reliably force underflow to 0 when the denominator Tim Peters <tim.peters@gmail.com> parents: 19719 diff changeset	2645 return PyFloat_FromDouble(0.0); /* underflow to 0 */
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2646 errno = 0;
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2647 ad = ldexp(ad, aexp * SHIFT);
19717 01de0a703069 Try to recover from that glibc's ldexp apparently doesn't set errno on Tim Peters <tim.peters@gmail.com> parents: 19677 diff changeset	2648 if (Py_OVERFLOWED(ad)) /* ignore underflow to 0.0 */
19677 91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2649 goto overflow;
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2650 return PyFloat_FromDouble(ad);
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2651
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2652 overflow:
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2653 PyErr_SetString(PyExc_OverflowError,
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2654 "long/long too large for a float");
91533675d6cb Change long/long true division to return as many good bits as it can; Tim Peters <tim.peters@gmail.com> parents: 19675 diff changeset	2655 return NULL;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2656
19675 685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2657 }
685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2658
685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2659 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2660 long_mod(PyObject v, PyObject w)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2661 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2662 PyLongObject a, b, *mod;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2663
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2664 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2665
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2666 if (l_divmod(a, b, NULL, &mod) < 0)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2667 mod = NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2668 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2669 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2670 return (PyObject *)mod;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2671 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2672
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2673 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2674 long_divmod(PyObject v, PyObject w)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2675 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2676 PyLongObject a, b, div, mod;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2677 PyObject *z;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2678
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2679 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2680
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2681 if (l_divmod(a, b, &div, &mod) < 0) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2682 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2683 Py_DECREF(b);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2684 return NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2685 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2686 z = PyTuple_New(2);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2687 if (z != NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2688 PyTuple_SetItem(z, 0, (PyObject *) div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2689 PyTuple_SetItem(z, 1, (PyObject *) mod);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2690 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2691 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2692 Py_DECREF(div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2693 Py_DECREF(mod);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2694 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2695 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2696 Py_DECREF(b);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2697 return z;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2698 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2699
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2700 /* pow(v, w, x) */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2701 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2702 long_pow(PyObject v, PyObject w, PyObject *x)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2703 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2704 PyLongObject a, b, c; / a,b,c = v,w,x */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2705 int negativeOutput = 0; /* if x<0 return negative output */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2706
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2707 PyLongObject z = NULL; / accumulated result */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2708 Py_ssize_t i, j, k; /* counters */
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2709 PyLongObject *temp = NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2710
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2711 /* 5-ary values. If the exponent is large enough, table is
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2712 * precomputed so that table[i] == a**i % c for i in range(32).
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2713 */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2714 PyLongObject *table[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2715 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2716
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2717 /* a, b, c = v, w, x */
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2718 CONVERT_BINOP(v, w, &a, &b);
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2719 if (PyLong_Check(x)) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2720 c = (PyLongObject *)x;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2721 Py_INCREF(x);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2722 }
35254 d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2723 else if (PyInt_Check(x)) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2724 c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x));
35254 d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2725 if (c == NULL)
d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2726 goto Error;
d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2727 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2728 else if (x == Py_None)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2729 c = NULL;
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2730 else {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2731 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2732 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2733 Py_INCREF(Py_NotImplemented);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2734 return Py_NotImplemented;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2735 }
19719 cdfdd5359411 Make the error msgs in our pow() implementations consistent. Tim Peters <tim.peters@gmail.com> parents: 19717 diff changeset	2736
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2737 if (b->ob_size < 0) { /* if exponent is negative */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2738 if (c) {
19719 cdfdd5359411 Make the error msgs in our pow() implementations consistent. Tim Peters <tim.peters@gmail.com> parents: 19717 diff changeset	2739 PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2740 "cannot be negative when 3rd argument specified");
33328 fee592fb5643 long_pow(): Fix more instances of leaks in error cases. Tim Peters <tim.peters@gmail.com> parents: 33327 diff changeset	2741 goto Error;
19666 cf65ebf87560 New restriction on pow(x, y, z): If z is not None, x and y must be of Tim Peters <tim.peters@gmail.com> parents: 19633 diff changeset	2742 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2743 else {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2744 /* else return a float. This works because we know
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2745 that this calls float_pow() which converts its
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2746 arguments to double. */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2747 Py_DECREF(a);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2748 Py_DECREF(b);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2749 return PyFloat_Type.tp_as_number->nb_power(v, w, x);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2750 }
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2751 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2752
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2753 if (c) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2754 /* if modulus == 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2755 raise ValueError() */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2756 if (c->ob_size == 0) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2757 PyErr_SetString(PyExc_ValueError,
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2758 "pow() 3rd argument cannot be 0");
33328 fee592fb5643 long_pow(): Fix more instances of leaks in error cases. Tim Peters <tim.peters@gmail.com> parents: 33327 diff changeset	2759 goto Error;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2760 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2761
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2762 /* if modulus < 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2763 negativeOutput = True
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2764 modulus = -modulus */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2765 if (c->ob_size < 0) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2766 negativeOutput = 1;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2767 temp = (PyLongObject *)_PyLong_Copy(c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2768 if (temp == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2769 goto Error;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2770 Py_DECREF(c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2771 c = temp;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2772 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2773 c->ob_size = - c->ob_size;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2774 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2775
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2776 /* if modulus == 1:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2777 return 0 */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2778 if ((c->ob_size == 1) && (c->ob_digit[0] == 1)) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2779 z = (PyLongObject *)PyLong_FromLong(0L);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2780 goto Done;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2781 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2782
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2783 /* if base < 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2784 base = base % modulus
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2785 Having the base positive just makes things easier. */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2786 if (a->ob_size < 0) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2787 if (l_divmod(a, c, NULL, &temp) < 0)
33328 fee592fb5643 long_pow(): Fix more instances of leaks in error cases. Tim Peters <tim.peters@gmail.com> parents: 33327 diff changeset	2788 goto Error;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2789 Py_DECREF(a);
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2790 a = temp;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2791 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2792 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2793 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2794
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2795 /* At this point a, b, and c are guaranteed non-negative UNLESS
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2796 c is NULL, in which case a may be negative. */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2797
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2798 z = (PyLongObject *)PyLong_FromLong(1L);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2799 if (z == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2800 goto Error;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2801
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2802 /* Perform a modular reduction, X = X % c, but leave X alone if c
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2803 * is NULL.
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2804 */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2805 #define REDUCE(X) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2806 if (c != NULL) { \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2807 if (l_divmod(X, c, NULL, &temp) < 0) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2808 goto Error; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2809 Py_XDECREF(X); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2810 X = temp; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2811 temp = NULL; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2812 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2813
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2814 /* Multiply two values, then reduce the result:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2815 result = XY % c. If c is NULL, skip the mod. /
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2816 #define MULT(X, Y, result) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2817 { \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2818 temp = (PyLongObject *)long_mul(X, Y); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2819 if (temp == NULL) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2820 goto Error; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2821 Py_XDECREF(result); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2822 result = temp; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2823 temp = NULL; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2824 REDUCE(result) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2825 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2826
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2827 if (b->ob_size <= FIVEARY_CUTOFF) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2828 /* Left-to-right binary exponentiation (HAC Algorithm 14.79) */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2829 /* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2830 for (i = b->ob_size - 1; i >= 0; --i) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2831 digit bi = b->ob_digit[i];
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2832
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2833 for (j = 1 << (SHIFT-1); j != 0; j >>= 1) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2834 MULT(z, z, z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2835 if (bi & j)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2836 MULT(z, a, z)
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2837 }
b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2838 }
b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2839 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2840 else {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2841 /* Left-to-right 5-ary exponentiation (HAC Algorithm 14.82) */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2842 Py_INCREF(z); /* still holds 1L */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2843 table[0] = z;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2844 for (i = 1; i < 32; ++i)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2845 MULT(table[i-1], a, table[i])
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2846
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2847 for (i = b->ob_size - 1; i >= 0; --i) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2848 const digit bi = b->ob_digit[i];
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2849
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2850 for (j = SHIFT - 5; j >= 0; j -= 5) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2851 const int index = (bi >> j) & 0x1f;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2852 for (k = 0; k < 5; ++k)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2853 MULT(z, z, z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2854 if (index)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2855 MULT(z, table[index], z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2856 }
11380 3e3c71f4d2de Fix PR#66. Solution: add error checking around l_divmod() calls in Guido van Rossum <guido@python.org> parents: 11331 diff changeset	2857 }
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	2858 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2859
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2860 if (negativeOutput && (z->ob_size != 0)) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2861 temp = (PyLongObject *)long_sub(z, c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2862 if (temp == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2863 goto Error;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2864 Py_DECREF(z);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2865 z = temp;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2866 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2867 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2868 goto Done;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2869
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2870 Error:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2871 if (z != NULL) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2872 Py_DECREF(z);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2873 z = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2874 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2875 /* fall through */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2876 Done:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2877 if (b->ob_size > FIVEARY_CUTOFF) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2878 for (i = 0; i < 32; ++i)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2879 Py_XDECREF(table[i]);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2880 }
35254 d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2881 Py_DECREF(a);
d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2882 Py_DECREF(b);
d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2883 Py_XDECREF(c);
d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2884 Py_XDECREF(temp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2885 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2886 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2887
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2888 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2889 long_invert(PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2890 {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2891 /* Implement ~x as -(x+1) */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2892 PyLongObject *x;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2893 PyLongObject *w;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2894 w = (PyLongObject *)PyLong_FromLong(1L);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2895 if (w == NULL)
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2896 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2897 x = (PyLongObject *) long_add(v, w);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2898 Py_DECREF(w);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2899 if (x == NULL)
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2900 return NULL;
19882 96f53f8831ee long_invert(): tiny speed and space optimization. Tim Peters <tim.peters@gmail.com> parents: 19880 diff changeset	2901 x->ob_size = -(x->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2902 return (PyObject *)x;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2903 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2904
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2905 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2906 long_pos(PyLongObject *v)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2907 {
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2908 if (PyLong_CheckExact(v)) {
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2909 Py_INCREF(v);
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2910 return (PyObject *)v;
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2911 }
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2912 else
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2913 return _PyLong_Copy(v);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2914 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2915
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2916 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2917 long_neg(PyLongObject *v)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2918 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2919 PyLongObject *z;
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2920 if (v->ob_size == 0 && PyLong_CheckExact(v)) {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2921 /* -0 == 0 */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2922 Py_INCREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2923 return (PyObject *) v;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2924 }
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2925 z = (PyLongObject *)_PyLong_Copy(v);
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2926 if (z != NULL)
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2927 z->ob_size = -(v->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2928 return (PyObject *)z;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2929 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2930
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2931 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2932 long_abs(PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2933 {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2934 if (v->ob_size < 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2935 return long_neg(v);
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2936 else
d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2937 return long_pos(v);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2938 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2939
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2940 static int
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	2941 long_nonzero(PyLongObject *v)
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2942 {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2943 return ABS(v->ob_size) != 0;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2944 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2945
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2946 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2947 long_rshift(PyLongObject v, PyLongObject w)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2948 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2949 PyLongObject a, b;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2950 PyLongObject *z = NULL;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2951 long shiftby;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2952 Py_ssize_t newsize, wordshift, loshift, hishift, i, j;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2953 digit lomask, himask;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2954
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2955 CONVERT_BINOP((PyObject )v, (PyObject )w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2956
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2957 if (a->ob_size < 0) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2958 /* Right shifting negative numbers is harder */
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2959 PyLongObject a1, a2;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2960 a1 = (PyLongObject *) long_invert(a);
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2961 if (a1 == NULL)
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2962 goto rshift_error;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2963 a2 = (PyLongObject *) long_rshift(a1, b);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2964 Py_DECREF(a1);
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2965 if (a2 == NULL)
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2966 goto rshift_error;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2967 z = (PyLongObject *) long_invert(a2);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2968 Py_DECREF(a2);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2969 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2970 else {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2971
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2972 shiftby = PyLong_AsLong((PyObject *)b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2973 if (shiftby == -1L && PyErr_Occurred())
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2974 goto rshift_error;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2975 if (shiftby < 0) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2976 PyErr_SetString(PyExc_ValueError,
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2977 "negative shift count");
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2978 goto rshift_error;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2979 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2980 wordshift = shiftby / SHIFT;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2981 newsize = ABS(a->ob_size) - wordshift;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2982 if (newsize <= 0) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2983 z = _PyLong_New(0);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2984 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2985 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2986 return (PyObject *)z;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2987 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2988 loshift = shiftby % SHIFT;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2989 hishift = SHIFT - loshift;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2990 lomask = ((digit)1 << hishift) - 1;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2991 himask = MASK ^ lomask;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2992 z = _PyLong_New(newsize);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2993 if (z == NULL)
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2994 goto rshift_error;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2995 if (a->ob_size < 0)
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2996 z->ob_size = -(z->ob_size);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2997 for (i = 0, j = wordshift; i < newsize; i++, j++) {
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2998 z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2999 if (i+1 < newsize)
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3000 z->ob_digit[i] \|=
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3001 (a->ob_digit[j+1] << hishift) & himask;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3002 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3003 z = long_normalize(z);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3004 }
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3005 rshift_error:
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3006 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3007 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3008 return (PyObject *) z;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3009
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3010 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3011
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3012 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3013 long_lshift(PyObject v, PyObject w)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3014 {
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3015 /* This version due to Tim Peters */
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3016 PyLongObject a, b;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3017 PyLongObject *z = NULL;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3018 long shiftby;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3019 Py_ssize_t oldsize, newsize, wordshift, remshift, i, j;
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3020 twodigits accum;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3021
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3022 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3023
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3024 shiftby = PyLong_AsLong((PyObject *)b);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3025 if (shiftby == -1L && PyErr_Occurred())
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3026 goto lshift_error;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3027 if (shiftby < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3028 PyErr_SetString(PyExc_ValueError, "negative shift count");
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3029 goto lshift_error;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3030 }
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3031 if ((long)(int)shiftby != shiftby) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3032 PyErr_SetString(PyExc_ValueError,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3033 "outrageous left shift count");
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3034 goto lshift_error;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3035 }
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3036 /* wordshift, remshift = divmod(shiftby, SHIFT) */
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3037 wordshift = (int)shiftby / SHIFT;
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3038 remshift = (int)shiftby - wordshift * SHIFT;
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3039
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3040 oldsize = ABS(a->ob_size);
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3041 newsize = oldsize + wordshift;
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3042 if (remshift)
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3043 ++newsize;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3044 z = _PyLong_New(newsize);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3045 if (z == NULL)
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3046 goto lshift_error;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3047 if (a->ob_size < 0)
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3048 z->ob_size = -(z->ob_size);
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3049 for (i = 0; i < wordshift; i++)
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3050 z->ob_digit[i] = 0;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3051 accum = 0;
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3052 for (i = wordshift, j = 0; j < oldsize; i++, j++) {
24919 4cb253c556b1 long_format(), long_lshift(): Someone on c.l.py is trying to boost Tim Peters <tim.peters@gmail.com> parents: 24847 diff changeset	3053 accum \|= (twodigits)a->ob_digit[j] << remshift;
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3054 z->ob_digit[i] = (digit)(accum & MASK);
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3055 accum >>= SHIFT;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3056 }
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3057 if (remshift)
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3058 z->ob_digit[newsize-1] = (digit)accum;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3059 else
5199 7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3060 assert(!accum);
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3061 z = long_normalize(z);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3062 lshift_error:
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3063 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3064 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3065 return (PyObject *) z;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3066 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3067
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3068
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3069 /* Bitwise and/xor/or operations */
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3070
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3071 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3072 long_bitwise(PyLongObject *a,
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3073 int op, /* '&', '\|', '^' */
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3074 PyLongObject *b)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3075 {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3076 digit maska, maskb; /* 0 or MASK */
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3077 int negz;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3078 Py_ssize_t size_a, size_b, size_z;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3079 PyLongObject *z;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3080 int i;
743 dbcb49d742a0 Lint stuff (involves casts, yuck!) Guido van Rossum <guido@python.org> parents: 613 diff changeset	3081 digit diga, digb;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3082 PyObject *v;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3083
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3084 if (a->ob_size < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3085 a = (PyLongObject *) long_invert(a);
36877 e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3086 if (a == NULL)
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3087 return NULL;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3088 maska = MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3089 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3090 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3091 Py_INCREF(a);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3092 maska = 0;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3093 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3094 if (b->ob_size < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3095 b = (PyLongObject *) long_invert(b);
36877 e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3096 if (b == NULL) {
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3097 Py_DECREF(a);
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3098 return NULL;
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3099 }
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3100 maskb = MASK;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3101 }
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3102 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3103 Py_INCREF(b);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3104 maskb = 0;
546 937cbc0be6ec Fixed bug in long masking ops. Guido van Rossum <guido@python.org> parents: 475 diff changeset	3105 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3106
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3107 negz = 0;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3108 switch (op) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3109 case '^':
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3110 if (maska != maskb) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3111 maska ^= MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3112 negz = -1;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3113 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3114 break;
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	3115 case '&':
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3116 if (maska && maskb) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3117 op = '\|';
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3118 maska ^= MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3119 maskb ^= MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3120 negz = -1;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3121 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3122 break;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3123 case '\|':
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3124 if (maska \|\| maskb) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3125 op = '&';
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3126 maska ^= MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3127 maskb ^= MASK;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3128 negz = -1;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3129 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3130 break;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3131 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3132
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3133 /* JRH: The original logic here was to allocate the result value (z)
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3134 as the longer of the two operands. However, there are some cases
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3135 where the result is guaranteed to be shorter than that: AND of two
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3136 positives, OR of two negatives: use the shorter number. AND with
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3137 mixed signs: use the positive number. OR with mixed signs: use the
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3138 negative number. After the transformations above, op will be '&'
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3139 iff one of these cases applies, and mask will be non-0 for operands
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3140 whose length should be ignored.
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3141 */
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3142
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3143 size_a = a->ob_size;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3144 size_b = b->ob_size;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3145 size_z = op == '&'
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3146 ? (maska
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3147 ? size_b
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3148 : (maskb ? size_a : MIN(size_a, size_b)))
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3149 : MAX(size_a, size_b);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3150 z = _PyLong_New(size_z);
36877 e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3151 if (z == NULL) {
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3152 Py_XDECREF(a);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3153 Py_XDECREF(b);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3154 Py_XDECREF(z);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3155 return NULL;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3156 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3157
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3158 for (i = 0; i < size_z; ++i) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3159 diga = (i < size_a ? a->ob_digit[i] : 0) ^ maska;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3160 digb = (i < size_b ? b->ob_digit[i] : 0) ^ maskb;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3161 switch (op) {
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3162 case '&': z->ob_digit[i] = diga & digb; break;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3163 case '\|': z->ob_digit[i] = diga \| digb; break;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3164 case '^': z->ob_digit[i] = diga ^ digb; break;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3165 }
546 937cbc0be6ec Fixed bug in long masking ops. Guido van Rossum <guido@python.org> parents: 475 diff changeset	3166 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3167
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3168 Py_DECREF(a);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3169 Py_DECREF(b);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3170 z = long_normalize(z);
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3171 if (negz == 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3172 return (PyObject *) z;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3173 v = long_invert(z);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3174 Py_DECREF(z);
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3175 return v;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3176 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3177
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3178 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3179 long_and(PyObject v, PyObject w)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3180 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3181 PyLongObject a, b;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3182 PyObject *c;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3183 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3184 c = long_bitwise(a, '&', b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3185 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3186 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3187 return c;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3188 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3189
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3190 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3191 long_xor(PyObject v, PyObject w)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3192 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3193 PyLongObject a, b;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3194 PyObject *c;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3195 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3196 c = long_bitwise(a, '^', b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3197 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3198 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3199 return c;
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3200 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3201
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3202 static PyObject *
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3203 long_or(PyObject v, PyObject w)
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3204 {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3205 PyLongObject a, b;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3206 PyObject *c;
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3207 CONVERT_BINOP(v, w, &a, &b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3208 c = long_bitwise(a, '\|', b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3209 Py_DECREF(a);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3210 Py_DECREF(b);
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3211 return c;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	3212 }
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	3213
1313 6ee380349c84 * Added gmtime/localtime/mktime and SYSV timezone globals to timemodule.c. Guido van Rossum <guido@python.org> parents: 1257 diff changeset	3214 static int
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3215 long_coerce(PyObject pv, PyObject pw)
955 03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3216 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3217 if (PyInt_Check(*pw)) {
15725 8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3218 pw = PyLong_FromLong(PyInt_AS_LONG(pw));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3219 Py_INCREF(*pv);
955 03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3220 return 0;
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3221 }
19976 da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3222 else if (PyLong_Check(*pw)) {
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3223 Py_INCREF(*pv);
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3224 Py_INCREF(*pw);
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3225 return 0;
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3226 }
955 03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3227 return 1; /* Can't do it */
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3228 }
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3229
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3230 static PyObject *
26291 d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3231 long_long(PyObject *v)
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3232 {
34931 9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3233 if (PyLong_CheckExact(v))
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3234 Py_INCREF(v);
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3235 else
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3236 v = _PyLong_Copy((PyLongObject *)v);
26291 d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3237 return v;
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3238 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3239
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3240 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3241 long_int(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3242 {
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3243 long x;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3244 x = PyLong_AsLong(v);
26291 d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3245 if (PyErr_Occurred()) {
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3246 if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3247 PyErr_Clear();
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3248 if (PyLong_CheckExact(v)) {
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3249 Py_INCREF(v);
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3250 return v;
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3251 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3252 else
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3253 return _PyLong_Copy((PyLongObject *)v);
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3254 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3255 else
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3256 return NULL;
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3257 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3258 return PyInt_FromLong(x);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3259 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3260
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3261 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3262 long_float(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3263 {
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4870 diff changeset	3264 double result;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3265 result = PyLong_AsDouble(v);
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	3266 if (result == -1.0 && PyErr_Occurred())
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	3267 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3268 return PyFloat_FromDouble(result);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3269 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3270
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3271 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3272 long_oct(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3273 {
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	3274 return long_format(v, 8, 1);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3275 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3276
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3277 static PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3278 long_hex(PyObject *v)
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3279 {
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	3280 return long_format(v, 16, 1);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3281 }
24280 1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24231 diff changeset	3282
1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24231 diff changeset	3283 static PyObject *
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3284 long_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3285
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3286 static PyObject *
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3287 long_new(PyTypeObject type, PyObject args, PyObject *kwds)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3288 {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3289 PyObject *x = NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3290 int base = -909; /* unlikely! */
36675 dba6494735d0 Revert backwards-incompatible const changes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	3291 static char *kwlist[] = {"x", "base", 0};
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3292
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3293 if (type != &PyLong_Type)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3294 return long_subtype_new(type, args, kwds); /* Wimp out */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3295 if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|Oi:long", kwlist,
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3296 &x, &base))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3297 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3298 if (x == NULL)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3299 return PyLong_FromLong(0L);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3300 if (base == -909)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3301 return PyNumber_Long(x);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3302 else if (PyString_Check(x))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3303 return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	3304 #ifdef Py_USING_UNICODE
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3305 else if (PyUnicode_Check(x))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3306 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x),
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3307 PyUnicode_GET_SIZE(x),
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3308 base);
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	3309 #endif
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3310 else {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3311 PyErr_SetString(PyExc_TypeError,
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3312 "long() can't convert non-string with explicit base");
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3313 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3314 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3315 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3316
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3317 /* Wimpy, slow approach to tp_new calls for subtypes of long:
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3318 first create a regular long from whatever arguments we got,
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3319 then allocate a subtype instance and initialize it from
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3320 the regular long. The regular long is then thrown away.
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3321 */
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3322 static PyObject *
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3323 long_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3324 {
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3325 PyLongObject tmp, newobj;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3326 Py_ssize_t i, n;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3327
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3328 assert(PyType_IsSubtype(type, &PyLong_Type));
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3329 tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds);
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3330 if (tmp == NULL)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3331 return NULL;
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	3332 assert(PyLong_CheckExact(tmp));
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3333 n = tmp->ob_size;
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3334 if (n < 0)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3335 n = -n;
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3336 newobj = (PyLongObject *)type->tp_alloc(type, n);
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3337 if (newobj == NULL) {
29641 4909aa64405f SF patch 703666: Several objects don't decref tmp on failure in subtype_new Raymond Hettinger <python@rcn.com> parents: 28981 diff changeset	3338 Py_DECREF(tmp);
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3339 return NULL;
29641 4909aa64405f SF patch 703666: Several objects don't decref tmp on failure in subtype_new Raymond Hettinger <python@rcn.com> parents: 28981 diff changeset	3340 }
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3341 assert(PyLong_Check(newobj));
aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3342 newobj->ob_size = tmp->ob_size;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3343 for (i = 0; i < n; i++)
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3344 newobj->ob_digit[i] = tmp->ob_digit[i];
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3345 Py_DECREF(tmp);
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3346 return (PyObject *)newobj;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3347 }
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3348
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3349 static PyObject *
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3350 long_getnewargs(PyLongObject *v)
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3351 {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3352 return Py_BuildValue("(N)", _PyLong_Copy(v));
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3353 }
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3354
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3355 static PyMethodDef long_methods[] = {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3356 {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS},
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3357 {NULL, NULL} /* sentinel */
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3358 };
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3359
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23248 diff changeset	3360 PyDoc_STRVAR(long_doc,
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3361 "long(x[, base]) -> integer\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3362 \n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3363 Convert a string or number to a long integer, if possible. A floating\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3364 point argument will be truncated towards zero (this does not include a\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3365 string representation of a floating point number!) When converting a\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3366 string, use the optional base. It is an error to supply a base when\n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23248 diff changeset	3367 converting a non-string.");
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3368
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3369 static PyNumberMethods long_as_number = {
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3370 (binaryfunc) long_add, /nb_add/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3371 (binaryfunc) long_sub, /nb_subtract/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3372 (binaryfunc) long_mul, /nb_multiply/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3373 long_classic_div, /nb_divide/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3374 long_mod, /nb_remainder/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3375 long_divmod, /nb_divmod/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3376 long_pow, /nb_power/
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3377 (unaryfunc) long_neg, /nb_negative/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3378 (unaryfunc) long_pos, /tp_positive/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3379 (unaryfunc) long_abs, /tp_absolute/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3380 (inquiry) long_nonzero, /tp_nonzero/
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3381 (unaryfunc) long_invert, /nb_invert/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3382 long_lshift, /nb_lshift/
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3383 (binaryfunc) long_rshift, /nb_rshift/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3384 long_and, /nb_and/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3385 long_xor, /nb_xor/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3386 long_or, /nb_or/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3387 long_coerce, /nb_coerce/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3388 long_int, /nb_int/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3389 long_long, /nb_long/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3390 long_float, /nb_float/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3391 long_oct, /nb_oct/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3392 long_hex, /nb_hex/
19051 f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3393 0, /* nb_inplace_add */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3394 0, /* nb_inplace_subtract */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3395 0, /* nb_inplace_multiply */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3396 0, /* nb_inplace_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3397 0, /* nb_inplace_remainder */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3398 0, /* nb_inplace_power */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3399 0, /* nb_inplace_lshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3400 0, /* nb_inplace_rshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3401 0, /* nb_inplace_and */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3402 0, /* nb_inplace_xor */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3403 0, /* nb_inplace_or */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3404 long_div, /* nb_floor_divide */
19051 f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3405 long_true_divide, /* nb_true_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3406 0, /* nb_inplace_floor_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3407 0, /* nb_inplace_true_divide */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3408 long_index, /* nb_index */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3409 };
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3410
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3411 PyTypeObject PyLong_Type = {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3412 PyObject_HEAD_INIT(&PyType_Type)
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3413 0, /* ob_size */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3414 "long", /* tp_name */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3415 sizeof(PyLongObject) - sizeof(digit), /* tp_basicsize */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3416 sizeof(digit), /* tp_itemsize */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3417 long_dealloc, /* tp_dealloc */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3418 0, /* tp_print */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3419 0, /* tp_getattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3420 0, /* tp_setattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3421 (cmpfunc)long_compare, /* tp_compare */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3422 long_repr, /* tp_repr */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3423 &long_as_number, /* tp_as_number */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3424 0, /* tp_as_sequence */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3425 0, /* tp_as_mapping */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3426 (hashfunc)long_hash, /* tp_hash */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3427 0, /* tp_call */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3428 long_str, /* tp_str */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3429 PyObject_GenericGetAttr, /* tp_getattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3430 0, /* tp_setattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3431 0, /* tp_as_buffer */
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3432 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_CHECKTYPES \|
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3433 Py_TPFLAGS_BASETYPE, /* tp_flags */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3434 long_doc, /* tp_doc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3435 0, /* tp_traverse */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3436 0, /* tp_clear */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3437 0, /* tp_richcompare */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3438 0, /* tp_weaklistoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3439 0, /* tp_iter */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3440 0, /* tp_iternext */
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3441 long_methods, /* tp_methods */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3442 0, /* tp_members */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3443 0, /* tp_getset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3444 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3445 0, /* tp_dict */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3446 0, /* tp_descr_get */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3447 0, /* tp_descr_set */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3448 0, /* tp_dictoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3449 0, /* tp_init */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3450 0, /* tp_alloc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3451 long_new, /* tp_new */
22974 72778ec94dec PyObject_Del can now be used as a function designator. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22204 diff changeset	3452 PyObject_Del, /* tp_free */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3453 };

Mercurial > cpython-lru_cache-weakref

annotate Objects/longobject.c @ 39042:c02fa187e0f4 legacy-trunk