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

annotate Objects/longobject.c @ 58925:eecf1bef052d 2.6

Merged revisions 78207 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r78207 | ezio.melotti | 2010-02-17 01:26:09 +0200 (Wed, 17 Feb 2010) | 1 line #7930: fix stripid ........

author	Ezio Melotti <ezio.melotti@gmail.com>
date	Tue, 16 Feb 2010 23:29:44 +0000
parents	f44f46fe8da5
children	e38335d4df91

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
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	14 * being an internal Python long digit, in base PyLong_BASE).
24745 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 *);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	38
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	39 #define SIGCHECK(PyTryBlock) \
25108 3a26e352f0a6 replace thread state objects' ticker and checkinterval fields with two Skip Montanaro <skip@pobox.com> parents: 24919 diff changeset	40 if (--_Py_Ticker < 0) { \
3a26e352f0a6 replace thread state objects' ticker and checkinterval fields with two Skip Montanaro <skip@pobox.com> parents: 24919 diff changeset	41 _Py_Ticker = _Py_CheckInterval; \
38331 7a6af4a143c6 Patch #1494387: SVN longobject.c compiler warnings Tim Peters <tim.peters@gmail.com> parents: 38307 diff changeset	42 if (PyErr_CheckSignals()) PyTryBlock \
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	43 }
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	44
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	45 /* Normalize (remove leading zeros from) a long int object.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	46 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	47 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	48
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	49 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	50 long_normalize(register PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	51 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	52 Py_ssize_t j = ABS(Py_SIZE(v));
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	53 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	54
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	55 while (i > 0 && v->ob_digit[i-1] == 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	56 --i;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	57 if (i != j)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	58 Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	59 return v;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	60 }
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 /* Allocate a new long int object with size digits.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	63 Return NULL and set exception if we run out of memory. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	64
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	65 PyLongObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	66 _PyLong_New(Py_ssize_t size)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	67 {
38139 f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	68 if (size > PY_SSIZE_T_MAX) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	69 PyErr_NoMemory();
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	70 return NULL;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	71 }
44749 55ddb166f1d1 Silence Coverity false alerts with CIDs #172, #183, #184 Christian Heimes <christian@cheimes.de> parents: 44488 diff changeset	72 /* coverity[ampersand_in_size] */
48114 c4d24fc8ba8a Security patches from Apple: prevent int overflow when allocating memory Neal Norwitz <nnorwitz@gmail.com> parents: 47922 diff changeset	73 /* XXX(nnorwitz): This can overflow --
c4d24fc8ba8a Security patches from Apple: prevent int overflow when allocating memory Neal Norwitz <nnorwitz@gmail.com> parents: 47922 diff changeset	74 PyObject_NEW_VAR / _PyObject_VAR_SIZE need to detect overflow */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	75 return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	76 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	77
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	78 PyObject *
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	79 _PyLong_Copy(PyLongObject *src)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	80 {
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	81 PyLongObject *result;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	82 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	83
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	84 assert(src != NULL);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	85 i = src->ob_size;
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	86 if (i < 0)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	87 i = -(i);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	88 result = _PyLong_New(i);
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	89 if (result != NULL) {
22147 1d1a01d956a2 backport tim_one's checkin of Michael W. Hudson <mwh@python.net> parents: 21968 diff changeset	90 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	91 while (--i >= 0)
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	92 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	93 }
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	94 return (PyObject *)result;
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	95 }
5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	96
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	97 /* Create a new long int object from a C long int */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	98
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	99 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	100 PyLong_FromLong(long ival)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	101 {
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	102 PyLongObject *v;
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	103 unsigned long abs_ival;
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	104 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	105 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	106 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	107
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 if (ival < 0) {
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	109 /* if LONG_MIN == -LONG_MAX-1 (true on most platforms) then
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	110 ANSI C says that the result of -ival is undefined when ival
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	111 == LONG_MIN. Hence the following workaround. */
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	112 abs_ival = (unsigned long)(-1-ival) + 1;
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	113 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	114 }
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	115 else {
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	116 abs_ival = (unsigned long)ival;
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	117 }
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	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 /* 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	120 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	121 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	122 needed. */
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	123 t = abs_ival;
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	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 ++ndigits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	126 t >>= PyLong_SHIFT;
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	127 }
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	128 v = _PyLong_New(ndigits);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	129 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	130 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	131 v->ob_size = negative ? -ndigits : ndigits;
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	132 t = abs_ival;
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	133 while (t) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	134 *p++ = (digit)(t & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	135 t >>= PyLong_SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	136 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	137 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	138 return (PyObject *)v;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	139 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	140
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	141 /* 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	142
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	143 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	144 PyLong_FromUnsignedLong(unsigned long ival)
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	145 {
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	146 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	147 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	148 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	149
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 /* 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	151 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	152 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	153 ++ndigits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	154 t >>= PyLong_SHIFT;
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	155 }
31cd0db0f09f PyLong_From{Unsigned,}Long: count the # of digits first, so no more space Tim Peters <tim.peters@gmail.com> parents: 18110 diff changeset	156 v = _PyLong_New(ndigits);
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	157 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	158 digit *p = v->ob_digit;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	159 Py_SIZE(v) = ndigits;
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	160 while (ival) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	161 *p++ = (digit)(ival & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	162 ival >>= PyLong_SHIFT;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	163 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	164 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	165 return (PyObject *)v;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	166 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	167
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	168 /* 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	169
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	170 PyObject *
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	171 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	172 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	173 PyLongObject *v;
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	174 double frac;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	175 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	176 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	177 if (Py_IS_INFINITY(dval)) {
11331 4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	178 PyErr_SetString(PyExc_OverflowError,
48177 6c6a030567dd Issue #1481296: (again!) Make conversion of a float NaN to an int or Mark Dickinson <dickinsm@gmail.com> parents: 48114 diff changeset	179 "cannot convert float infinity to integer");
11331 4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	180 return NULL;
4fdc9c1ecaf6 Patch by Tim Peters fixing PR#89: Guido van Rossum <guido@python.org> parents: 9969 diff changeset	181 }
44448 5e0170d3c4da Bug #1481296: Fixed long(float('nan'))!=0L. Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	182 if (Py_IS_NAN(dval)) {
48177 6c6a030567dd Issue #1481296: (again!) Make conversion of a float NaN to an int or Mark Dickinson <dickinsm@gmail.com> parents: 48114 diff changeset	183 PyErr_SetString(PyExc_ValueError,
6c6a030567dd Issue #1481296: (again!) Make conversion of a float NaN to an int or Mark Dickinson <dickinsm@gmail.com> parents: 48114 diff changeset	184 "cannot convert float NaN to integer");
6c6a030567dd Issue #1481296: (again!) Make conversion of a float NaN to an int or Mark Dickinson <dickinsm@gmail.com> parents: 48114 diff changeset	185 return NULL;
44448 5e0170d3c4da Bug #1481296: Fixed long(float('nan'))!=0L. Christian Heimes <christian@cheimes.de> parents: 44432 diff changeset	186 }
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	187 if (dval < 0.0) {
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	188 neg = 1;
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	189 dval = -dval;
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 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	192 if (expo <= 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	193 return PyLong_FromLong(0L);
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	194 ndig = (expo-1) / PyLong_SHIFT + 1; /* Number of 'digits' in result */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	195 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	196 if (v == NULL)
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	197 return NULL;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	198 frac = ldexp(frac, (expo-1) % PyLong_SHIFT + 1);
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	199 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	200 long bits = (long)frac;
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	201 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	202 frac = frac - (double)bits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	203 frac = ldexp(frac, PyLong_SHIFT);
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	204 }
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	205 if (neg)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	206 Py_SIZE(v) = -(Py_SIZE(v));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	207 return (PyObject *)v;
254 71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	208 }
71b0bd5ed162 Added dnewlongobject(), function to convert double to long int. Guido van Rossum <guido@python.org> parents: 250 diff changeset	209
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	210 /* Checking for overflow in PyLong_AsLong is a PITA since C doesn't define
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	211 * anything about what happens when a signed integer operation overflows,
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	212 * and some compilers think they're doing you a favor by being "clever"
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	213 * then. The bit pattern for the largest postive signed long is
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	214 * (unsigned long)LONG_MAX, and for the smallest negative signed long
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	215 * it is abs(LONG_MIN), which we could write -(unsigned long)LONG_MIN.
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	216 * However, some other compilers warn about applying unary minus to an
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	217 * unsigned operand. Hence the weird "0-".
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	218 */
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	219 #define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN)
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	220 #define PY_ABS_SSIZE_T_MIN (0-(size_t)PY_SSIZE_T_MIN)
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	221
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	222 /* Get a C long int from a long int object.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	223 Returns -1 and sets an error condition if overflow occurs. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	224
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	225 long
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	226 PyLong_AsLong(PyObject *vv)
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 /* This version by Tim Peters */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	229 register PyLongObject *v;
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	230 unsigned long x, prev;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	231 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	232 int sign;
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	233
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	234 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	235 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	236 return PyInt_AsLong(vv);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	237 PyErr_BadInternalCall();
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	238 return -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	239 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	240 v = (PyLongObject *)vv;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	241 i = v->ob_size;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	242 sign = 1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	243 x = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	244 if (i < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	245 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	246 i = -(i);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	247 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	248 while (--i >= 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	249 prev = x;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	250 x = (x << PyLong_SHIFT) + v->ob_digit[i];
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	251 if ((x >> PyLong_SHIFT) != prev)
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	252 goto overflow;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	253 }
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	254 /* Haven't lost any bits, but casting to long requires extra care
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	255 * (see comment above).
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	256 */
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	257 if (x <= (unsigned long)LONG_MAX) {
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	258 return (long)x * sign;
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	259 }
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	260 else if (sign < 0 && x == PY_ABS_LONG_MIN) {
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	261 return LONG_MIN;
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	262 }
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	263 /* else overflow */
8425 e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	264
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	265 overflow:
e2d41bf1a0f0 Subject: Buglet in PyLong_AsLong Guido van Rossum <guido@python.org> parents: 7981 diff changeset	266 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	267 "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	268 return -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	269 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	270
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	271 /* Get a Py_ssize_t from a long int object.
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	272 Returns -1 and sets an error condition if overflow occurs. */
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	273
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	274 Py_ssize_t
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	275 PyLong_AsSsize_t(PyObject *vv) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	276 register PyLongObject *v;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	277 size_t x, prev;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	278 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	279 int sign;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	280
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	281 if (vv == NULL \|\| !PyLong_Check(vv)) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	282 PyErr_BadInternalCall();
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	283 return -1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	284 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	285 v = (PyLongObject *)vv;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	286 i = v->ob_size;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	287 sign = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	288 x = 0;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	289 if (i < 0) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	290 sign = -1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	291 i = -(i);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	292 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	293 while (--i >= 0) {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	294 prev = x;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	295 x = (x << PyLong_SHIFT) + v->ob_digit[i];
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	296 if ((x >> PyLong_SHIFT) != prev)
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	297 goto overflow;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	298 }
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	299 /* Haven't lost any bits, but casting to a signed type requires
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	300 * extra care (see comment above).
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	301 */
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	302 if (x <= (size_t)PY_SSIZE_T_MAX) {
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	303 return (Py_ssize_t)x * sign;
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	304 }
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	305 else if (sign < 0 && x == PY_ABS_SSIZE_T_MIN) {
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	306 return PY_SSIZE_T_MIN;
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	307 }
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	308 /* else overflow */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	309
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	310 overflow:
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	311 PyErr_SetString(PyExc_OverflowError,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	312 "long int too large to convert to int");
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	313 return -1;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	314 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	315
24777 696a284569e6 Fix comment for PyLong_AsUnsignedLong() to say that the return value Guido van Rossum <guido@python.org> parents: 24775 diff changeset	316 /* 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	317 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	318
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	319 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	320 PyLong_AsUnsignedLong(PyObject *vv)
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	321 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	322 register PyLongObject *v;
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	323 unsigned long x, prev;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	324 Py_ssize_t i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	325
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	326 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	327 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	328 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	329 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	330 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	331 "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	332 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	333 }
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	334 return val;
30d428f992f9 Patch #1024670: Support int objects in PyLong_AsUnsignedLong[Mask]. Martin v. Löwis <martin@v.loewis.de> parents: 33328 diff changeset	335 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	336 PyErr_BadInternalCall();
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	337 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	338 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	339 v = (PyLongObject *)vv;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	340 i = Py_SIZE(v);
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	341 x = 0;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	342 if (i < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	343 PyErr_SetString(PyExc_OverflowError,
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	344 "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	345 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	346 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	347 while (--i >= 0) {
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	348 prev = x;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	349 x = (x << PyLong_SHIFT) + v->ob_digit[i];
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	350 if ((x >> PyLong_SHIFT) != prev) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	351 PyErr_SetString(PyExc_OverflowError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	352 "long int too large to convert");
4870 68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	353 return (unsigned long) -1;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	354 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	355 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	356 return x;
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	357 }
68f4134869db Added PyLong_FromUnsignedLong() and PyLong_AsUnsignedLong(). Guido van Rossum <guido@python.org> parents: 4587 diff changeset	358
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	359 /* 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	360 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	361
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	362 unsigned long
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	363 PyLong_AsUnsignedLongMask(PyObject *vv)
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	364 {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	365 register PyLongObject *v;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	366 unsigned long x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	367 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	368 int sign;
28652 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 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	371 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	372 return PyInt_AsUnsignedLongMask(vv);
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	373 PyErr_BadInternalCall();
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	374 return (unsigned long) -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	375 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	376 v = (PyLongObject *)vv;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	377 i = v->ob_size;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	378 sign = 1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	379 x = 0;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	380 if (i < 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	381 sign = -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	382 i = -i;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	383 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	384 while (--i >= 0) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	385 x = (x << PyLong_SHIFT) + v->ob_digit[i];
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	386 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	387 return x * sign;
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
27549 7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	390 int
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	391 _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	392 {
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	393 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	394
7fcdeeb16ec0 _PyLong_NumBits(): The definition of this was too specific to the quirky Tim Peters <tim.peters@gmail.com> parents: 27521 diff changeset	395 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	396 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	397
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	398 return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 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	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
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	401 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	402 _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	403 {
0904d878b8f1 Added new private API function _PyLong_NumBits. This will be used at the Tim Peters <tim.peters@gmail.com> parents: 26867 diff changeset	404 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	405 size_t result = 0;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	406 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	407
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 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	409 assert(PyLong_Check(v));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	410 ndigits = ABS(Py_SIZE(v));
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	411 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	412 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	413 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	414
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	415 result = (ndigits - 1) * PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	416 if (result / PyLong_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	417 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	418 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	419 ++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	420 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	421 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	422 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	423 } 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	424 }
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 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	426
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 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	428 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	429 "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	430 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	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
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	433 PyObject *
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	434 _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	435 int little_endian, int is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	436 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	437 const unsigned char* pstartbyte;/* LSB of bytes */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	438 int incr; /* direction to move pstartbyte */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	439 const unsigned char* pendbyte; /* MSB of bytes */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	440 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	441 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	442 PyLongObject* v; /* result */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	443 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	444
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	445 if (n == 0)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	446 return PyLong_FromLong(0L);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	447
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	448 if (little_endian) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	449 pstartbyte = bytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	450 pendbyte = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	451 incr = 1;
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 else {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	454 pstartbyte = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	455 pendbyte = bytes;
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
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	459 if (is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	460 is_signed = *pendbyte >= 0x80;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	461
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	462 /* 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	463 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	464 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	465 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	466 size_t i;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	467 const unsigned char* p = pendbyte;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	468 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	469 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	470
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	471 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	472 if (*p != insignficant)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	473 break;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	474 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	475 numsignificantbytes = n - i;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	476 /* 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	477 actually has 2 significant bytes. OTOH, 0xff0001 ==
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	478 -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	479 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	480 check every case, bump it regardless. */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	481 if (is_signed && numsignificantbytes < n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	482 ++numsignificantbytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	483 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	484
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	485 /* How many Python long digits do we need? We have
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	486 8*numsignificantbytes bits, and each Python long digit has PyLong_SHIFT
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	487 bits, so it's the ceiling of the quotient. */
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	488 ndigits = (numsignificantbytes * 8 + PyLong_SHIFT - 1) / PyLong_SHIFT;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	489 if (ndigits > (size_t)INT_MAX)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	490 return PyErr_NoMemory();
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	491 v = _PyLong_New((int)ndigits);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	492 if (v == NULL)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	493 return NULL;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	494
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	495 /* 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	496 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	497 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	498 {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	499 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	500 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	501 twodigits accum = 0; /* sliding register */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	502 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	503 const unsigned char* p = pstartbyte;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	504
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	505 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	506 twodigits thisbyte = *p;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	507 /* 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	508 if (is_signed) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	509 thisbyte = (0xff ^ thisbyte) + carry;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	510 carry = thisbyte >> 8;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	511 thisbyte &= 0xff;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	512 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	513 /* 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	514 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	515 so needs to be prepended to accum. */
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	516 accum \|= (twodigits)thisbyte << accumbits;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	517 accumbits += 8;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	518 if (accumbits >= PyLong_SHIFT) {
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	519 /* 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	520 assert(idigit < (int)ndigits);
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	521 v->ob_digit[idigit] = (digit)(accum & PyLong_MASK);
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	522 ++idigit;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	523 accum >>= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	524 accumbits -= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	525 assert(accumbits < PyLong_SHIFT);
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	526 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	527 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	528 assert(accumbits < PyLong_SHIFT);
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	529 if (accumbits) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	530 assert(idigit < (int)ndigits);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	531 v->ob_digit[idigit] = (digit)accum;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	532 ++idigit;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	533 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	534 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	535
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	536 Py_SIZE(v) = is_signed ? -idigit : idigit;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	537 return (PyObject *)long_normalize(v);
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 int
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	541 _PyLong_AsByteArray(PyLongObject* v,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	542 unsigned char* bytes, size_t n,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	543 int little_endian, int is_signed)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	544 {
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	545 Py_ssize_t i; /* index into v->ob_digit */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	546 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	547 twodigits accum; /* sliding register */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	548 unsigned int accumbits; /* # bits in accum */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	549 int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */
51051 096b488438e9 Merged revisions 68947 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51005 diff changeset	550 digit carry; /* for computing 2's-comp */
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	551 size_t j; /* # bytes filled */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	552 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	553 int pincr; /* direction to move p */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	554
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	555 assert(v != NULL && PyLong_Check(v));
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	556
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	557 if (Py_SIZE(v) < 0) {
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	558 ndigits = -(Py_SIZE(v));
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	559 if (!is_signed) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	560 PyErr_SetString(PyExc_TypeError,
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	561 "can't convert negative long to unsigned");
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	562 return -1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	563 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	564 do_twos_comp = 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	565 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	566 else {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	567 ndigits = Py_SIZE(v);
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	568 do_twos_comp = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	569 }
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 if (little_endian) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	572 p = bytes;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	573 pincr = 1;
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 else {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	576 p = bytes + n - 1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	577 pincr = -1;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	578 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	579
18108 8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	580 /* 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	581 It's crucial that every Python digit except for the MSD contribute
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	582 exactly PyLong_SHIFT bits to the total, so first assert that the long is
18108 8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	583 normalized. */
8cf72b187b3a _PyLong_AsByteArray: added assert that the input is normalized. This is Tim Peters <tim.peters@gmail.com> parents: 18107 diff changeset	584 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	585 j = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	586 accum = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	587 accumbits = 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	588 carry = do_twos_comp ? 1 : 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	589 for (i = 0; i < ndigits; ++i) {
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	590 digit thisdigit = v->ob_digit[i];
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	591 if (do_twos_comp) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	592 thisdigit = (thisdigit ^ PyLong_MASK) + carry;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	593 carry = thisdigit >> PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	594 thisdigit &= PyLong_MASK;
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	595 }
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	596 /* 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	597 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	598 prepended to accum. */
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	599 accum \|= (twodigits)thisdigit << accumbits;
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	600
18115 2ecaf9e21a04 _PyLong_AsByteArray: simplify the logic for dealing with the most- Tim Peters <tim.peters@gmail.com> parents: 18114 diff changeset	601 /* 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	602 partly empty. */
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	603 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	604 /* 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	605 * although for signed conversion we need later to
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	606 * make sure at least one sign bit gets stored. */
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	607 digit s = do_twos_comp ? thisdigit ^ PyLong_MASK :
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	608 thisdigit;
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	609 while (s != 0) {
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	610 s >>= 1;
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	611 accumbits++;
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	612 }
bbcdbd8f4469 Added q/Q standard (x-platform 8-byte ints) mode in struct module. Tim Peters <tim.peters@gmail.com> parents: 18082 diff changeset	613 }
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	614 else
db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	615 accumbits += PyLong_SHIFT;
18091 a001fcb76177 _PyLong_{As,From}ByteArray: Minor code rearrangement aimed at improving Tim Peters <tim.peters@gmail.com> parents: 18084 diff changeset	616
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	617 /* 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	618 while (accumbits >= 8) {
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	619 if (j >= n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	620 goto Overflow;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	621 ++j;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	622 *p = (unsigned char)(accum & 0xff);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	623 p += pincr;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	624 accumbits -= 8;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	625 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	626 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	627 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	628
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	629 /* Store the straggler (if any). */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	630 assert(accumbits < 8);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	631 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	632 if (accumbits > 0) {
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	633 if (j >= n)
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	634 goto Overflow;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	635 ++j;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	636 if (do_twos_comp) {
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	637 /* 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	638 (appropriately pretending that the long had an
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	639 infinite supply of sign bits). */
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	640 accum \|= (~(twodigits)0) << accumbits;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	641 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	642 *p = (unsigned char)(accum & 0xff);
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	643 p += pincr;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	644 }
18109 be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	645 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	646 /* 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	647 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	648 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	649 exists. */
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	650 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	651 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	652 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	653 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	654 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	655 else
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	656 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	657 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	658
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	659 /* 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	660 {
be2ddb25b698 _PyLong_AsByteArray: Don't do the "delicate overflow" check unless it's Tim Peters <tim.peters@gmail.com> parents: 18108 diff changeset	661 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	662 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	663 *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	664 }
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	665
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	666 return 0;
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	667
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	668 Overflow:
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	669 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	670 return -1;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	671
18082 dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	672 }
dd09f11fa40d Two new private longobject API functions, Tim Peters <tim.peters@gmail.com> parents: 15946 diff changeset	673
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	674 double
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	675 _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	676 {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	677 /* 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	678 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	679 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	680 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	681 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	682
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	683 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	684 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	685 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	686 */
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	687 #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	688 PyLongObject *v;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	689 double x;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	690 const double multiplier = (double)(1L << PyLong_SHIFT);
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	691 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	692 int sign;
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	693 int nbitsneeded;
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 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	696 PyErr_BadInternalCall();
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	697 return -1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	698 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	699 v = (PyLongObject *)vv;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	700 i = Py_SIZE(v);
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	701 sign = 1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	702 if (i < 0) {
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	703 sign = -1;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	704 i = -(i);
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	705 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	706 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	707 *exponent = 0;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	708 return 0.0;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	709 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	710 --i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	711 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	712 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	713 /* 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	714 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	715 --i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	716 x = x * multiplier + (double)v->ob_digit[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	717 nbitsneeded -= PyLong_SHIFT;
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	718 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	719 /* There are i digits we didn't shift in. Pretending they're all
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	720 zeroes, the true value is x * 2*(iPyLong_SHIFT). */
19671 7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	721 *exponent = i;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	722 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	723 return x * sign;
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	724 #undef NBITS_WANTED
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	725 }
7df300d284c6 Introduce new private API function _PyLong_AsScaledDouble. Not used yet, Tim Peters <tim.peters@gmail.com> parents: 19666 diff changeset	726
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4870 diff changeset	727 /* Get a C double from a long int object. */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	728
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	729 double
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	730 PyLong_AsDouble(PyObject *vv)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	731 {
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	732 int e = -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	733 double x;
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	734
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	735 if (vv == NULL \|\| !PyLong_Check(vv)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	736 PyErr_BadInternalCall();
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	737 return -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	738 }
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	739 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	740 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	741 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	742 /* '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	743 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	744 assert(e >= 0);
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	745 if (e > INT_MAX / PyLong_SHIFT)
19674 715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	746 goto overflow;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	747 errno = 0;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	748 x = ldexp(x, e * PyLong_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	749 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	750 goto overflow;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	751 return x;
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	752
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	753 overflow:
715244108faa Raise OverflowError when appropriate on long->float conversion. Most of Tim Peters <tim.peters@gmail.com> parents: 19671 diff changeset	754 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	755 "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	756 return -1.0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	757 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	758
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	759 /* 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	760
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	761 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	762 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	763 {
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	764 #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	765 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	766 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	767 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	768 #else
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	769
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	770 #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	771 # 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	772 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	773 #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	774 # 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	775 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	776 /* optimize null pointers */
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	777 if (p == NULL)
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	778 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	779 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	780
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	781 #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	782 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	783
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	784 /* 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	785
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	786 void *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	787 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	788 {
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	789 /* 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	790 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	791 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	792 */
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	793 #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	794 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	795
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	796 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	797 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	798 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	799 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	800 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	801 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	802 #else
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	803
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	804 #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	805 # 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	806 #endif
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	807 #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	808 # 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	809 #endif
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	810 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	811
18134 eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	812 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	813 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	814 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	815 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	816 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	817 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	818
eff8da7c3dcb PyLong_{As, From}VoidPtr: cleanup, replacing assumptions in comments with Tim Peters <tim.peters@gmail.com> parents: 18121 diff changeset	819 #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	820
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	821 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	822 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	823 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	824 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 9094 diff changeset	825
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	826 #ifdef HAVE_LONG_LONG
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	827
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	828 /* 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	829 * 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	830 */
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	831
18121 166b7b365851 Change IS_LITTLE_ENDIAN macro -- a little faster now. Tim Peters <tim.peters@gmail.com> parents: 18115 diff changeset	832 #define IS_LITTLE_ENDIAN (int)(unsigned char)&one
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	833
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	834 /* 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	835
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	836 PyObject *
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	837 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	838 {
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	839 PyLongObject *v;
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	840 unsigned PY_LONG_LONG abs_ival;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	841 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	842 int ndigits = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	843 int negative = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	844
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	845 if (ival < 0) {
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	846 /* avoid signed overflow on negation; see comments
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	847 in PyLong_FromLong above. */
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	848 abs_ival = (unsigned PY_LONG_LONG)(-1-ival) + 1;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	849 negative = 1;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	850 }
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	851 else {
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	852 abs_ival = (unsigned PY_LONG_LONG)ival;
38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	853 }
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	854
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	855 /* 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	856 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	857 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	858 needed. */
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	859 t = abs_ival;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	860 while (t) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	861 ++ndigits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	862 t >>= PyLong_SHIFT;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	863 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	864 v = _PyLong_New(ndigits);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	865 if (v != NULL) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	866 digit *p = v->ob_digit;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	867 Py_SIZE(v) = negative ? -ndigits : ndigits;
46459 38c831b47dc5 Fix for possible signed overflow: the behaviour of -LONG_MIN is Mark Dickinson <dickinsm@gmail.com> parents: 46149 diff changeset	868 t = abs_ival;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	869 while (t) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	870 *p++ = (digit)(t & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	871 t >>= PyLong_SHIFT;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	872 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	873 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	874 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	875 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	876
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	877 /* 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	878
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	879 PyObject *
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	880 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	881 {
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	882 PyLongObject *v;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	883 unsigned PY_LONG_LONG t;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	884 int ndigits = 0;
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	885
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	886 /* 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	887 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	888 while (t) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	889 ++ndigits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	890 t >>= PyLong_SHIFT;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	891 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	892 v = _PyLong_New(ndigits);
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	893 if (v != NULL) {
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	894 digit *p = v->ob_digit;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	895 Py_SIZE(v) = ndigits;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	896 while (ival) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	897 *p++ = (digit)(ival & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	898 ival >>= PyLong_SHIFT;
38307 5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	899 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	900 }
5a63369056a7 Faster path for PyLong_FromLongLong, using PyLong_FromLong algorithm Bob Ippolito <bob@redivi.com> parents: 38301 diff changeset	901 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	902 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	903
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	904 /* 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	905
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	906 PyObject *
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	907 PyLong_FromSsize_t(Py_ssize_t ival)
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	908 {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	909 Py_ssize_t bytes = ival;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	910 int one = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	911 return _PyLong_FromByteArray(
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	912 (unsigned char *)&bytes,
41590 1c1705bf36b8 Fix problems in x64 build that were discovered by the testsuite: Kristján Valur Jónsson <kristjan@ccpgames.com> parents: 41435 diff changeset	913 SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1);
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	914 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	915
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	916 /* 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	917
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	918 PyObject *
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	919 PyLong_FromSize_t(size_t ival)
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	920 {
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	921 size_t bytes = ival;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	922 int one = 1;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	923 return _PyLong_FromByteArray(
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	924 (unsigned char *)&bytes,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	925 SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0);
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	926 }
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	927
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	928 /* 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	929 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	930
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	931 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	932 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	933 {
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	934 PY_LONG_LONG bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	935 int one = 1;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	936 int res;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	937
20182 6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	938 if (vv == NULL) {
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	939 PyErr_BadInternalCall();
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	940 return -1;
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	941 }
6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	942 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	943 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	944 PyObject *io;
20182 6d73b54d9205 SF [#466125] PyLong_AsLongLong works for any integer. Tim Peters <tim.peters@gmail.com> parents: 19976 diff changeset	945 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	946 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	947 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	948 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	949 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	950 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	951 }
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 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	953 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	954 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	955 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	956 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	957 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	958 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	959 }
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 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	961 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	962 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	963 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	964 }
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 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	966 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	967 return -1;
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	968 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	969
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	970 res = _PyLong_AsByteArray(
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	971 (PyLongObject )vv, (unsigned char )&bytes,
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	972 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	973
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	974 /* 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	975 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	976 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	977 else
928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	978 return bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	979 }
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	980
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	981 /* 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	982 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	983
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	984 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	985 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	986 {
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	987 unsigned PY_LONG_LONG bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	988 int one = 1;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	989 int res;
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	990
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	991 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	992 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	993 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	994 }
bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	995
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	996 res = _PyLong_AsByteArray(
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	997 (PyLongObject )vv, (unsigned char )&bytes,
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	998 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	999
28437 871da703e4c0 Rename LONG_LONG to PY_LONG_LONG. Fixes #710285. Martin v. Löwis <martin@v.loewis.de> parents: 28032 diff changeset	1000 /* 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	1001 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	1002 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	1003 else
928c1282e5e2 Patch #494047: removes 64-bit ?: to cope on plan9. Martin v. Löwis <martin@v.loewis.de> parents: 22147 diff changeset	1004 return bytes;
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1005 }
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1006
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1007 /* 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	1008 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	1009
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1010 unsigned PY_LONG_LONG
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1011 PyLong_AsUnsignedLongLongMask(PyObject *vv)
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1012 {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1013 register PyLongObject *v;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1014 unsigned PY_LONG_LONG x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1015 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1016 int sign;
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1017
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1018 if (vv == NULL \|\| !PyLong_Check(vv)) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1019 PyErr_BadInternalCall();
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1020 return (unsigned long) -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1021 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1022 v = (PyLongObject *)vv;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1023 i = v->ob_size;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1024 sign = 1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1025 x = 0;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1026 if (i < 0) {
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1027 sign = -1;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1028 i = -i;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1029 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1030 while (--i >= 0) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1031 x = (x << PyLong_SHIFT) + v->ob_digit[i];
28652 28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1032 }
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1033 return x * sign;
28a2975514cd SF # 595026: support for masks in getargs.c. Thomas Heller <theller@ctypes.org> parents: 28437 diff changeset	1034 }
18093 6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1035 #undef IS_LITTLE_ENDIAN
6ea366a2b2a6 longobject.c: Tim Peters <tim.peters@gmail.com> parents: 18091 diff changeset	1036
8822 bd47ee068b83 Changes for BeOS, QNX and long long, by Chris Herborth. Guido van Rossum <guido@python.org> parents: 8808 diff changeset	1037 #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	1038
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	1039
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	1040 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	1041 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	1042 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	1043 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	1044 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	1045 }
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 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	1047 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	1048 }
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 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	1050 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	1051 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1052 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	1053 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	1054 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	1055 }
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 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	1057 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	1058 }
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 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	1060 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	1061 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	1062 }
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 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	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
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 #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	1067 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	1068 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	1069 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	1070 }
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
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	1072 /* 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	1073 * 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	1074 * 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	1075 */
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 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1077 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	1078 {
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1079 Py_ssize_t i;
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 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	1081
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 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	1083 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	1084 carry += x[i] + y[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1085 x[i] = carry & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1086 carry >>= PyLong_SHIFT;
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	1087 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	1088 }
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 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	1090 carry += x[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1091 x[i] = carry & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1092 carry >>= PyLong_SHIFT;
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	1093 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	1094 }
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 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	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
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 /* 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	1099 * 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	1100 * 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	1101 */
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 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1103 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	1104 {
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1105 Py_ssize_t i;
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 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	1107
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 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	1109 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	1110 borrow = x[i] - y[i] - borrow;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1111 x[i] = borrow & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1112 borrow >>= PyLong_SHIFT;
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	1113 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	1114 }
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 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	1116 borrow = x[i] - borrow;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1117 x[i] = borrow & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1118 borrow >>= PyLong_SHIFT;
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	1119 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	1120 }
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 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	1122 }
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	1123
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1124 /* Multiply by a single digit, ignoring the sign. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1125
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1126 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	1127 mul1(PyLongObject *a, wdigit n)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1128 {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1129 return muladd1(a, n, (digit)0);
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
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1132 /* 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	1133
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1134 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	1135 muladd1(PyLongObject *a, wdigit n, wdigit extra)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1136 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1137 Py_ssize_t size_a = ABS(Py_SIZE(a));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1138 PyLongObject *z = _PyLong_New(size_a+1);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1139 twodigits carry = extra;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1140 Py_ssize_t i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1141
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1142 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1143 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1144 for (i = 0; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1145 carry += (twodigits)a->ob_digit[i] * n;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1146 z->ob_digit[i] = (digit) (carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1147 carry >>= PyLong_SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1148 }
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1149 z->ob_digit[i] = (digit) carry;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1150 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1151 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1152
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1153 /* 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	1154 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	1155 It's OK for pin == pout on entry, which saves oodles of mallocs/frees in
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1156 _PyLong_Format, but that should be done with great care since longs are
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1157 immutable. */
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1158
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1159 static digit
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1160 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	1161 {
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1162 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	1163
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1164 assert(n > 0 && n <= PyLong_MASK);
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1165 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	1166 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	1167 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	1168 digit hi;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1169 rem = (rem << PyLong_SHIFT) + *--pin;
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1170 *--pout = hi = (digit)(rem / n);
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1171 rem -= (twodigits)hi * 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	1172 }
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1173 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	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
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1176 /* Divide a long integer by a digit, returning both the quotient
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1177 (as function result) and the remainder (through *prem).
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1178 The sign of a is ignored; n should not be zero. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1179
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1180 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	1181 divrem1(PyLongObject a, digit n, digit prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1182 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1183 const Py_ssize_t size = ABS(Py_SIZE(a));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1184 PyLongObject *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1185
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1186 assert(n > 0 && n <= PyLong_MASK);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1187 z = _PyLong_New(size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1188 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1189 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	1190 *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1191 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1192 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1193
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1194 /* Convert the long to a string object with given base,
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1195 appending a base prefix of 0[box] if base is 2, 8 or 16.
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1196 Add a trailing "L" if addL is non-zero.
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1197 If newstyle is zero, then use the pre-2.6 behavior of octal having
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1198 a leading "0", instead of the prefix "0o" */
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1199 PyAPI_FUNC(PyObject *)
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1200 _PyLong_Format(PyObject *aa, int base, int addL, int newstyle)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1201 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1202 register PyLongObject a = (PyLongObject )aa;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1203 PyStringObject *str;
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1204 Py_ssize_t i, sz;
39141 bc5d831f1dda Move the initialization of size_a down below the check for a being NULL. Neal Norwitz <nnorwitz@gmail.com> parents: 39095 diff changeset	1205 Py_ssize_t size_a;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1206 char *p;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1207 int bits;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1208 char sign = '\0';
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1209
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1210 if (a == NULL \|\| !PyLong_Check(a)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1211 PyErr_BadInternalCall();
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1212 return NULL;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1213 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1214 assert(base >= 2 && base <= 36);
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1215 size_a = ABS(Py_SIZE(a));
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 }
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1224 i = 5 + (addL ? 1 : 0);
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1225 /* ensure we don't get signed overflow in sz calculation */
f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1226 if (size_a > (PY_SSIZE_T_MAX - i) / PyLong_SHIFT) {
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1227 PyErr_SetString(PyExc_OverflowError,
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1228 "long is too large to format");
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1229 return NULL;
6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1230 }
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1231 sz = i + 1 + (size_a * PyLong_SHIFT - 1) / bits;
f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1232 assert(sz >= 0);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1233 str = (PyStringObject ) PyString_FromStringAndSize((char )0, sz);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1234 if (str == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1235 return NULL;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1236 p = PyString_AS_STRING(str) + sz;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1237 *p = '\0';
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1238 if (addL)
f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1239 *--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	1240 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	1241 sign = '-';
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1242
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1243 if (a->ob_size == 0) {
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1244 *--p = '0';
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1245 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1246 else if ((base & (base - 1)) == 0) {
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1247 /* 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	1248 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	1249 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	1250 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	1251 i = base;
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1252 while ((i >>= 1) > 1)
a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1253 ++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	1254
0857fb489fa3 long_format: Simplify the overly elaborate base-is-a-power-of-2 code. Tim Peters <tim.peters@gmail.com> parents: 18594 diff changeset	1255 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	1256 accum \|= (twodigits)a->ob_digit[i] << accumbits;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1257 accumbits += PyLong_SHIFT;
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	1258 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	1259 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	1260 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	1261 cdigit += (cdigit < 10) ? '0' : 'a'-10;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1262 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	1263 *--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	1264 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	1265 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	1266 } while (i < size_a-1 ? accumbits >= basebits :
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1267 accum > 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1268 }
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1269 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1270 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	1271 /* 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	1272 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	1273 fits in a digit. */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1274 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	1275 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	1276 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	1277 /* 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	1278 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	1279 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	1280 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	1281 unsigned long newpow = powbase * (unsigned long)base;
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1282 if (newpow >> PyLong_SHIFT)
f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1283 /* doesn't fit 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	1284 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	1285 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	1286 ++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	1287 }
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1288
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1289 /* 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	1290 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	1291 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	1292 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	1293 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	1294 }
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1295
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1296 /* Repeatedly divide by powbase. */
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1297 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	1298 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	1299 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	1300 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	1301 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	1302 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	1303 --size;
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1304 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	1305 Py_DECREF(scratch);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1306 Py_DECREF(str);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1307 return NULL;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1308 })
18594 19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1309
19250f9181dc divrem1 & long_format: found a clean way to factor divrem1 so that Tim Peters <tim.peters@gmail.com> parents: 18593 diff changeset	1310 /* Break rem into digits. */
18593 9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1311 assert(ntostore > 0);
9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1312 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	1313 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	1314 char c = (char)(rem - nextrem * base);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1315 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	1316 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	1317 *--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	1318 rem = nextrem;
18593 9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1319 --ntostore;
9a373a143a13 long_format(): Simplify new code a bit. Tim Peters <tim.peters@gmail.com> parents: 18536 diff changeset	1320 /* 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	1321 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	1322 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	1323 } 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	1324 } 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	1325 Py_DECREF(scratch);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1326 }
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1327
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1328 if (base == 2) {
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1329 *--p = 'b';
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1330 *--p = '0';
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1331 }
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1332 else if (base == 8) {
55936 f44f46fe8da5 Merged revisions 74769 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 55862 diff changeset	1333 if (newstyle) {
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1334 *--p = 'o';
958 a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1335 *--p = '0';
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1336 }
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1337 else
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1338 if (size_a != 0)
86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1339 *--p = '0';
958 a736ef1840a5 oct(0) should return '0', not '00' Guido van Rossum <guido@python.org> parents: 955 diff changeset	1340 }
406 e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1341 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	1342 *--p = 'x';
e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1343 *--p = '0';
e628d09ce22f Changed convert to add '0' or '0x' prefix for oct/hex. Guido van Rossum <guido@python.org> parents: 284 diff changeset	1344 }
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1345 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	1346 *--p = '#';
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1347 *--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	1348 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	1349 *--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	1350 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1351 if (sign)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1352 *--p = sign;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1353 if (p != PyString_AS_STRING(str)) {
52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1354 char *q = PyString_AS_STRING(str);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1355 assert(p > q);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1356 do {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1357 } while ((q++ = p++) != '\0');
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	1358 q--;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1359 _PyString_Resize((PyObject **)&str,
52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1360 (Py_ssize_t) (q - PyString_AS_STRING(str)));
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1361 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1362 return (PyObject *)str;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1363 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1364
38301 dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1365 /* 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	1366 * '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	1367 * '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	1368 * 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	1369 * 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	1370 * 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	1371 */
dccbcbbd6720 A new table to help string->integer conversion was added yesterday to Tim Peters <tim.peters@gmail.com> parents: 38283 diff changeset	1372 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	1373 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	1374 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	1375 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	1376 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	1377 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	1378 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	1379 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	1380 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	1381 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	1382 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	1383 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	1384 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	1385 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	1386 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	1387 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	1388 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	1389 };
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1390
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1391 /* *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	1392 * 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	1393 * 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	1394 * 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	1395 * 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	1396 */
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	1397 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	1398 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	1399 {
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	1400 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	1401 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	1402 int bits_per_char;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1403 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	1404 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	1405 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	1406 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	1407 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	1408
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 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	1410 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	1411 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	1412 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	1413 /* n <- total # of bits needed, while setting p to end-of-string */
46149 7fdff02e6f45 Revert r61969 which added casts to Py_CHARMASK to avoid compiler warnings. Neal Norwitz <nnorwitz@gmail.com> parents: 46132 diff changeset	1414 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	1415 ++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	1416 *str = p;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1417 /* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1418 n = (p - start) * bits_per_char + PyLong_SHIFT - 1;
39995 6ba402b60041 Forward-port of r52136,52138: a review of overflow-detecting code. Armin Rigo <arigo@tunes.org> parents: 39463 diff changeset	1419 if (n / bits_per_char < p - start) {
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	1420 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	1421 "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	1422 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	1423 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1424 n = n / PyLong_SHIFT;
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 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	1426 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	1427 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	1428 /* 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	1429 * 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	1430 */
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 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	1432 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	1433 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	1434 while (--p >= start) {
46149 7fdff02e6f45 Revert r61969 which added casts to Py_CHARMASK to avoid compiler warnings. Neal Norwitz <nnorwitz@gmail.com> parents: 46132 diff changeset	1435 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	1436 assert(k >= 0 && k < base);
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1437 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	1438 bits_in_accum += bits_per_char;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1439 if (bits_in_accum >= PyLong_SHIFT) {
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1440 *pdigit++ = (digit)(accum & PyLong_MASK);
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1441 assert(pdigit - z->ob_digit <= n);
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1442 accum >>= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1443 bits_in_accum -= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1444 assert(bits_in_accum < PyLong_SHIFT);
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	1445 }
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	1446 }
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	1447 if (bits_in_accum) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1448 assert(bits_in_accum <= PyLong_SHIFT);
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	1449 *pdigit++ = (digit)accum;
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1450 assert(pdigit - z->ob_digit <= 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	1451 }
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	1452 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	1453 *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	1454 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	1455 }
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	1456
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1457 PyObject *
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1458 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	1459 {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1460 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	1461 char start, orig_str = str;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1462 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	1463 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	1464 Py_ssize_t slen;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1465
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	1466 if ((base != 0 && base < 2) \|\| base > 36) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1467 PyErr_SetString(PyExc_ValueError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	1468 "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	1469 return NULL;
87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1470 }
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	1471 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	1472 str++;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1473 if (*str == '+')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1474 ++str;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1475 else if (*str == '-') {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1476 ++str;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1477 sign = -1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1478 }
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	1479 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	1480 str++;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1481 if (base == 0) {
45791 62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1482 /* No base given. Deduce the base from the contents
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1483 of the string */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1484 if (str[0] != '0')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1485 base = 10;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1486 else if (str[1] == 'x' \|\| str[1] == 'X')
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1487 base = 16;
45791 62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1488 else if (str[1] == 'o' \|\| str[1] == 'O')
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1489 base = 8;
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1490 else if (str[1] == 'b' \|\| str[1] == 'B')
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1491 base = 2;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1492 else
45791 62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1493 /* "old" (C-style) octal literal, still valid in
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1494 2.x, although illegal in 3.x */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1495 base = 8;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1496 }
45791 62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1497 /* Whether or not we were deducing the base, skip leading chars
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1498 as needed */
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1499 if (str[0] == '0' &&
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1500 ((base == 16 && (str[1] == 'x' \|\| str[1] == 'X')) \|\|
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1501 (base == 8 && (str[1] == 'o' \|\| str[1] == 'O')) \|\|
62ef0ea034f4 Finished backporting PEP 3127, Integer Literal Support and Syntax. Eric Smith <eric@trueblade.com> parents: 45381 diff changeset	1502 (base == 2 && (str[1] == 'b' \|\| str[1] == 'B'))))
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1503 str += 2;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1504
8533 e5d06a602469 Add check in long-to-int conversion for at least one digit. Guido van Rossum <guido@python.org> parents: 8425 diff changeset	1505 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	1506 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	1507 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	1508 else {
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1509 /***
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1510 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	1511 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	1512 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	1513
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1514 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	1515 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	1516 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	1517
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1518 PyLong_BASEn-1 >= BN-1 [or, adding 1 to both sides]
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1519 PyLong_BASEn >= BN [taking logs to base PyLong_BASE]
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1520 n >= log(B*N)/log(PyLong_BASE) = N log(B)/log(PyLong_BASE)
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1521
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1522 The static array log_base_PyLong_BASE[base] == log(base)/log(PyLong_BASE) so we can compute
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1523 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	1524 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	1525
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1526 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	1527 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	1528
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1529 convwidth_base[base] = the largest integer i such that base**i <= PyLong_BASE
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1530 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	1531
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1532 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	1533 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	1534 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	1535
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1536 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	1537 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	1538
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1539 (((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	1540
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1541 where B = convmultmax_base[base].
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1542
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1543 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	1544 case
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1545
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1546 n >= N * log(B)/log(PyLong_BASE)
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1547
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1548 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	1549
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1550 size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1;
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1551
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1552 below. Two numeric concerns are how much space this can waste, and whether
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1553 the computed result can be too small. To be concrete, assume PyLong_BASE = 2**15,
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1554 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	1555
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1556 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	1557 between the worst-case input with N digits and the smallest input with N
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1558 digits is about a factor of B, but B is small compared to PyLong_BASE so at most
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1559 one allocated Python digit can remain unused on that count. If
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1560 N*log(B)/log(PyLong_BASE) is mathematically an exact integer, then truncating that
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1561 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	1562 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	1563 instead, and it's impossible for Bi to be an integer power of 215 when
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1564 B is not a power of 2 (i.e., it's impossible for N*log(B)/log(PyLong_BASE) to be
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1565 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	1566 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	1567
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1568 The computed result can be too small if the true value of N*log(B)/log(PyLong_BASE)
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1569 is a little bit larger than an exact integer, but due to roundoff errors (in
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1570 computing log(B), log(PyLong_BASE), their quotient, and/or multiplying that by N)
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1571 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	1572 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	1573 questions are generally theoretically intractable. Computer analysis via
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1574 continued fractions is practical: expand log(B)/log(PyLong_BASE) via continued
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1575 fractions, giving a sequence i/j of "the best" rational approximations. Then
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1576 j*log(B)/log(PyLong_BASE) is approximately equal to (the integer) i. This shows that
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1577 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	1578 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	1579 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	1580
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1581 >>> log(10)/log(2*15)76573
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1582 16958.000000654003
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1583
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1584 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	1585 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	1586 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	1587 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	1588 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	1589 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	1590 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	1591 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	1592 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	1593 ***/
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1594 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	1595 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	1596 int i;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1597 int convwidth;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1598 twodigits convmultmax, convmult;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1599 digit pz, pzstop;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1600 char* scan;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1601
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1602 static double log_base_PyLong_BASE[37] = {0.0e0,};
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1603 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	1604 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	1605
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1606 if (log_base_PyLong_BASE[base] == 0.0) {
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1607 twodigits convmax = base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1608 int i = 1;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1609
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1610 log_base_PyLong_BASE[base] = log((double)base) /
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1611 log((double)PyLong_BASE);
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1612 for (;;) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1613 twodigits next = convmax * base;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1614 if (next > PyLong_BASE)
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1615 break;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1616 convmax = next;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1617 ++i;
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 convmultmax_base[base] = convmax;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1620 assert(i > 0);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1621 convwidth_base[base] = i;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1622 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1623
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1624 /* 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	1625 scan = str;
46149 7fdff02e6f45 Revert r61969 which added casts to Py_CHARMASK to avoid compiler warnings. Neal Norwitz <nnorwitz@gmail.com> parents: 46132 diff changeset	1626 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	1627 ++scan;
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 /* 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	1630 * 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	1631 * 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	1632 * being stored into.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1633 */
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1634 size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1;
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1635 /* 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	1636 /* size_z = 1; */
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1637 assert(size_z > 0);
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1638 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	1639 if (z == NULL)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1640 return NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1641 Py_SIZE(z) = 0;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1642
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1643 /* `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	1644 * digit in base `convmultmax`.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1645 */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1646 convwidth = convwidth_base[base];
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1647 convmultmax = convmultmax_base[base];
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1648
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1649 /* Work ;-) */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1650 while (str < scan) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1651 /* grab up to convwidth digits from the input string */
46149 7fdff02e6f45 Revert r61969 which added casts to Py_CHARMASK to avoid compiler warnings. Neal Norwitz <nnorwitz@gmail.com> parents: 46132 diff changeset	1652 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	1653 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	1654 c = (twodigits)(c * base +
46149 7fdff02e6f45 Revert r61969 which added casts to Py_CHARMASK to avoid compiler warnings. Neal Norwitz <nnorwitz@gmail.com> parents: 46132 diff changeset	1655 _PyLong_DigitValue[Py_CHARMASK(*str)]);
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1656 assert(c < PyLong_BASE);
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1657 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1658
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1659 convmult = convmultmax;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1660 /* 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	1661 * convwidth digits.
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1662 */
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1663 if (i != convwidth) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1664 convmult = base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1665 for ( ; i > 1; --i)
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1666 convmult *= base;
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1667 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1668
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1669 /* 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	1670 pz = z->ob_digit;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1671 pzstop = pz + Py_SIZE(z);
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1672 for (; pz < pzstop; ++pz) {
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1673 c += (twodigits)pz convmult;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1674 *pz = (digit)(c & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1675 c >>= PyLong_SHIFT;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1676 }
88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1677 /* 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	1678 if (c) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1679 assert(c < PyLong_BASE);
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1680 if (Py_SIZE(z) < size_z) {
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1681 *pz = (digit)c;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1682 ++Py_SIZE(z);
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1683 }
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1684 else {
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1685 PyLongObject *tmp;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1686 /* Extremely rare. Get more space. */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1687 assert(Py_SIZE(z) == size_z);
38513 7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1688 tmp = _PyLong_New(size_z + 1);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1689 if (tmp == NULL) {
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1690 Py_DECREF(z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1691 return NULL;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1692 }
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1693 memcpy(tmp->ob_digit,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1694 z->ob_digit,
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1695 sizeof(digit) * size_z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1696 Py_DECREF(z);
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1697 z = tmp;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1698 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	1699 ++size_z;
7f1f36b3c9f9 PyLong_FromString(): Continued fraction analysis (explained in Tim Peters <tim.peters@gmail.com> parents: 38331 diff changeset	1700 }
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1701 }
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	1702 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1703 }
8808 78785985a2ab Fix a potential problem in PyLong_FromString(): could fall through the Guido van Rossum <guido@python.org> parents: 8533 diff changeset	1704 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	1705 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	1706 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	1707 goto onError;
38283 88cc7e4f01ff Heavily fiddled variant of patch #1442927: PyLong_FromString optimization. Tim Peters <tim.peters@gmail.com> parents: 38139 diff changeset	1708 if (sign < 0)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1709 Py_SIZE(z) = -(Py_SIZE(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	1710 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	1711 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	1712 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	1713 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	1714 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	1715 goto onError;
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1716 if (pend)
87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1717 *pend = str;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1718 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	1719
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 onError:
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1721 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	1722 slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1723 strobj = PyString_FromStringAndSize(orig_str, slen);
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1724 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	1725 return NULL;
7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1726 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	1727 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	1728 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	1729 return NULL;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1730 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	1731 "invalid literal for long() with base %d: %s",
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	1732 base, PyString_AS_STRING(strrepr));
37611 7afaa752c772 Fix int() and long() to repr() their argument when formatting the exception, Thomas Wouters <thomas@python.org> parents: 37589 diff changeset	1733 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	1734 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	1735 }
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	1736
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	1737 #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	1738 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1739 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	1740 {
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1741 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	1742 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	1743
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1744 if (buffer == NULL)
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1745 return NULL;
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1746
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1747 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	1748 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	1749 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	1750 }
26081 999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1751 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	1752 PyMem_FREE(buffer);
999accfa91c5 Make int("...") return a long if an int would overflow. Walter Dörwald <walter@livinglogic.de> parents: 25108 diff changeset	1753 return result;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1754 }
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	1755 #endif
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1756
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1757 /* forward */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1758 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	1759 (PyLongObject , PyLongObject , PyLongObject **);
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	1760 static PyObject long_long(PyObject v);
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	1761 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	1762 PyLongObject , PyLongObject );
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1763
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1764 /* Long division with remainder, top-level routine */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1765
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1766 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	1767 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	1768 PyLongObject pdiv, PyLongObject prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1769 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1770 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1771 PyLongObject *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1772
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1773 if (size_b == 0) {
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	1774 PyErr_SetString(PyExc_ZeroDivisionError,
15318 8aa947e1eee8 Ka-Ping Yee <ping@lfw.org>: Fred Drake <fdrake@acm.org> parents: 15041 diff changeset	1775 "long division or modulo by zero");
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1776 return -1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1777 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1778 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	1779 (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	1780 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	1781 /* \|a\| < \|b\|. */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1782 *pdiv = _PyLong_New(0);
41435 46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1783 if (*pdiv == NULL)
46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1784 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1785 Py_INCREF(a);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1786 prem = (PyLongObject ) a;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1787 return 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1788 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1789 if (size_b == 1) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1790 digit rem = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1791 z = divrem1(a, b->ob_digit[0], &rem);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1792 if (z == NULL)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1793 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1794 prem = (PyLongObject ) PyLong_FromLong((long)rem);
41435 46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1795 if (*prem == NULL) {
46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1796 Py_DECREF(z);
46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1797 return -1;
46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	1798 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1799 }
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1800 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1801 z = x_divrem(a, b, prem);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1802 if (z == NULL)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1803 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1804 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1805 /* Set the signs.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1806 The quotient z has the sign of a*b;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1807 the remainder r has the sign of a,
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1808 so a = bz + r. /
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1809 if ((a->ob_size < 0) != (b->ob_size < 0))
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1810 z->ob_size = -(z->ob_size);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1811 if (a->ob_size < 0 && (*prem)->ob_size != 0)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1812 (prem)->ob_size = -((prem)->ob_size);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1813 *pdiv = z;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1814 return 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1815 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1816
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1817 /* Unsigned long division with remainder -- the algorithm */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1818
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1819 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	1820 x_divrem(PyLongObject v1, PyLongObject w1, PyLongObject **prem)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1821 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1822 Py_ssize_t size_v = ABS(Py_SIZE(v1)), size_w = ABS(Py_SIZE(w1));
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1823 digit d = (digit) ((twodigits)PyLong_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	1824 PyLongObject *v = mul1(v1, d);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1825 PyLongObject *w = mul1(w1, d);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1826 PyLongObject *a;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1827 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	1828
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1829 if (v == NULL \|\| w == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1830 Py_XDECREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1831 Py_XDECREF(w);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1832 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1833 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1834
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1835 assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1836 assert(Py_REFCNT(v) == 1); /* Since v will be used as accumulator! */
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1837 assert(size_w == ABS(Py_SIZE(w))); /* That's how d was calculated */
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1838
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1839 size_v = ABS(Py_SIZE(v));
38139 f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1840 k = size_v - size_w;
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1841 a = _PyLong_New(k + 1);
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1842
f1e24452dbba Fix problems found by Coverity. Neal Norwitz <nnorwitz@gmail.com> parents: 37815 diff changeset	1843 for (j = size_v; a != NULL && k >= 0; --j, --k) {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1844 digit vj = (j >= size_v) ? 0 : v->ob_digit[j];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1845 twodigits q;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1846 stwodigits carry = 0;
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	1847 Py_ssize_t i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1848
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1849 SIGCHECK({
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1850 Py_DECREF(a);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1851 a = NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1852 break;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	1853 })
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1854 if (vj == w->ob_digit[size_w-1])
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1855 q = PyLong_MASK;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1856 else
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1857 q = (((twodigits)vj << PyLong_SHIFT) + v->ob_digit[j-1]) /
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1858 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	1859
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1860 while (w->ob_digit[size_w-2]*q >
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1861 ((
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1862 ((twodigits)vj << PyLong_SHIFT)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1863 + v->ob_digit[j-1]
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1864 - q*w->ob_digit[size_w-1]
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1865 ) << PyLong_SHIFT)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1866 + v->ob_digit[j-2])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1867 --q;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1868
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1869 for (i = 0; i < size_w && i+k < size_v; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1870 twodigits z = w->ob_digit[i] * q;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1871 digit zz = (digit) (z >> PyLong_SHIFT);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1872 carry += v->ob_digit[i+k] - z
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1873 + ((twodigits)zz << PyLong_SHIFT);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1874 v->ob_digit[i+k] = (digit)(carry & PyLong_MASK);
52246 c5b7958f4292 PyLong_BASE_TWODIGITS_TYPE should be BASE_TWODIGITS_TYPE Mark Dickinson <dickinsm@gmail.com> parents: 51076 diff changeset	1875 carry = Py_ARITHMETIC_RIGHT_SHIFT(BASE_TWODIGITS_TYPE,
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1876 carry, PyLong_SHIFT);
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1877 carry -= zz;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1878 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1879
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1880 if (i+k < size_v) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1881 carry += v->ob_digit[i+k];
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1882 v->ob_digit[i+k] = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1883 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1884
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1885 if (carry == 0)
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1886 a->ob_digit[k] = (digit) q;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1887 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1888 assert(carry == -1);
5288 0f1711b7d367 Tweaks to keep the Microsoft compiler quiet. Guido van Rossum <guido@python.org> parents: 5199 diff changeset	1889 a->ob_digit[k] = (digit) q-1;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1890 carry = 0;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1891 for (i = 0; i < size_w && i+k < size_v; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1892 carry += v->ob_digit[i+k] + w->ob_digit[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1893 v->ob_digit[i+k] = (digit)(carry & PyLong_MASK);
13423 a87803eb9dfb Cray J90 fixes for long ints. Tim Peters <tim.peters@gmail.com> parents: 13420 diff changeset	1894 carry = Py_ARITHMETIC_RIGHT_SHIFT(
52246 c5b7958f4292 PyLong_BASE_TWODIGITS_TYPE should be BASE_TWODIGITS_TYPE Mark Dickinson <dickinsm@gmail.com> parents: 51076 diff changeset	1895 BASE_TWODIGITS_TYPE,
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1896 carry, PyLong_SHIFT);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1897 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1898 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1899 } /* for j, k */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1900
2111 30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1901 if (a == NULL)
30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1902 *prem = NULL;
30cbe024df40 fix memory leak and null pointer dereference Guido van Rossum <guido@python.org> parents: 2059 diff changeset	1903 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1904 a = long_normalize(a);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1905 *prem = divrem1(v, d, &d);
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1906 /* d receives the (unused) remainder */
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1907 if (*prem == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1908 Py_DECREF(a);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	1909 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	1910 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1911 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1912 Py_DECREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1913 Py_DECREF(w);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1914 return a;
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
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1917 /* Methods */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1918
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1919 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	1920 long_dealloc(PyObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1921 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1922 Py_TYPE(v)->tp_free(v);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1923 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1924
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	1925 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	1926 long_repr(PyObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1927 {
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1928 return _PyLong_Format(v, 10, 1, 0);
11628 47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1929 }
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1930
47f93a969366 long_format(): Now takes a third parameter, addL; iff true, a Fred Drake <fdrake@acm.org> parents: 11380 diff changeset	1931 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	1932 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	1933 {
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	1934 return _PyLong_Format(v, 10, 0, 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1935 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1936
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1937 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	1938 long_compare(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1939 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1940 Py_ssize_t sign;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	1941
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1942 if (Py_SIZE(a) != Py_SIZE(b)) {
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1943 if (ABS(Py_SIZE(a)) == 0 && ABS(Py_SIZE(b)) == 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	1944 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	1945 else
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1946 sign = Py_SIZE(a) - Py_SIZE(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	1947 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1948 else {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1949 Py_ssize_t i = ABS(Py_SIZE(a));
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1950 while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1951 ;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1952 if (i < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1953 sign = 0;
1191 38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1954 else {
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1955 sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	1956 if (Py_SIZE(a) < 0)
1191 38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1957 sign = -sign;
38f0054f44a7 Added separate main program for the Mac: macmain.c Guido van Rossum <guido@python.org> parents: 1051 diff changeset	1958 }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1959 }
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	1960 return sign < 0 ? -1 : sign > 0 ? 1 : 0;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1961 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	1962
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1963 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	1964 long_hash(PyLongObject *v)
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1965 {
51076 ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1966 unsigned long x;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1967 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	1968 int sign;
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1969
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1970 /* 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	1971 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	1972 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	1973 i = v->ob_size;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1974 sign = 1;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1975 x = 0;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1976 if (i < 0) {
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1977 sign = -1;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1978 i = -(i);
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1979 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1980 #define LONG_BIT_PyLong_SHIFT (8*sizeof(long) - PyLong_SHIFT)
51076 ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1981 /* The following loop produces a C unsigned long x such that x is
ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1982 congruent to the absolute value of v modulo ULONG_MAX. The
43406 357f54015a2d Issue #1772851. Alters long.__hash__ from being almost completely Facundo Batista <facundobatista@gmail.com> parents: 42333 diff changeset	1983 resulting x is nonzero if and only if v is. */
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1984 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	1985 /* Force a native long #-bits (32 or 64) circular shift */
51076 ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1986 x = ((x << PyLong_SHIFT) & ~PyLong_MASK) \|
ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1987 ((x >> LONG_BIT_PyLong_SHIFT) & PyLong_MASK);
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1988 x += v->ob_digit[i];
51076 ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1989 /* If the addition above overflowed we compensate by
ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1990 incrementing. This preserves the value modulo
ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1991 ULONG_MAX. */
ca8ea52b45c3 Merged revisions 68974-68975 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 51051 diff changeset	1992 if (x < v->ob_digit[i])
43406 357f54015a2d Issue #1772851. Alters long.__hash__ from being almost completely Facundo Batista <facundobatista@gmail.com> parents: 42333 diff changeset	1993 x++;
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1994 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	1995 #undef LONG_BIT_PyLong_SHIFT
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1996 x = x * sign;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1997 if (x == -1)
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1998 x = -2;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	1999 return x;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	2000 }
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	2001
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 1252 diff changeset	2002
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2003 /* Add the absolute values of two long integers. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2004
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2005 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	2006 x_add(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2007 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2008 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2009 PyLongObject *z;
51005 db0ffeee6e50 Merged revisions 68890 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 48177 diff changeset	2010 Py_ssize_t i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2011 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	2012
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2013 /* Ensure a is the larger of the two: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2014 if (size_a < size_b) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2015 { 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	2016 { Py_ssize_t size_temp = size_a;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2017 size_a = size_b;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2018 size_b = size_temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2019 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2020 z = _PyLong_New(size_a+1);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2021 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2022 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2023 for (i = 0; i < size_b; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2024 carry += a->ob_digit[i] + b->ob_digit[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2025 z->ob_digit[i] = carry & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2026 carry >>= PyLong_SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2027 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2028 for (; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2029 carry += a->ob_digit[i];
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2030 z->ob_digit[i] = carry & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2031 carry >>= PyLong_SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2032 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2033 z->ob_digit[i] = carry;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2034 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2035 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2036
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2037 /* Subtract the absolute values of two integers. */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2038
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2039 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	2040 x_sub(PyLongObject a, PyLongObject b)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2041 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2042 Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2043 PyLongObject *z;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2044 Py_ssize_t i;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2045 int sign = 1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2046 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	2047
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2048 /* Ensure a is the larger of the two: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2049 if (size_a < size_b) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2050 sign = -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2051 { 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	2052 { Py_ssize_t size_temp = size_a;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2053 size_a = size_b;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2054 size_b = size_temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2055 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2056 else if (size_a == size_b) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2057 /* Find highest digit where a and b differ: */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2058 i = size_a;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2059 while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2060 ;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2061 if (i < 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2062 return _PyLong_New(0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2063 if (a->ob_digit[i] < b->ob_digit[i]) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2064 sign = -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2065 { PyLongObject *temp = a; a = b; b = temp; }
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2066 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2067 size_a = size_b = i+1;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2068 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2069 z = _PyLong_New(size_a);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2070 if (z == NULL)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2071 return NULL;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2072 for (i = 0; i < size_b; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2073 /* The following assumes unsigned arithmetic
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2074 works module 2*N for some N>PyLong_SHIFT. /
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	2075 borrow = a->ob_digit[i] - b->ob_digit[i] - borrow;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2076 z->ob_digit[i] = borrow & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2077 borrow >>= PyLong_SHIFT;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2078 borrow &= 1; /* Keep only one sign bit */
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2079 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2080 for (; i < size_a; ++i) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2081 borrow = a->ob_digit[i] - borrow;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2082 z->ob_digit[i] = borrow & PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2083 borrow >>= PyLong_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	2084 borrow &= 1; /* Keep only one sign bit */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2085 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2086 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	2087 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	2088 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2089 return long_normalize(z);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2090 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2091
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2092 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	2093 long_add(PyLongObject v, PyLongObject w)
230 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 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	2096
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	2097 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	2098
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2099 if (a->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2100 if (b->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2101 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	2102 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	2103 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2104 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2105 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2106 z = x_sub(b, a);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2107 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2108 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2109 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2110 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2111 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2112 z = x_add(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2113 }
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 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	2115 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2116 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2117 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2118
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2119 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	2120 long_sub(PyLongObject v, PyLongObject w)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2121 {
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	2122 PyLongObject a, b, *z;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2123
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	2124 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	2125
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2126 if (a->ob_size < 0) {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2127 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2128 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2129 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2130 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	2131 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	2132 z->ob_size = -(z->ob_size);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2133 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2134 else {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2135 if (b->ob_size < 0)
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2136 z = x_add(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2137 else
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2138 z = x_sub(a, b);
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2139 }
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	2140 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	2141 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2142 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2143 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2144
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2145 /* 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	2146 * 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	2147 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2148 static PyLongObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2149 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	2150 {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2151 PyLongObject *z;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2152 Py_ssize_t size_a = ABS(Py_SIZE(a));
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2153 Py_ssize_t size_b = ABS(Py_SIZE(b));
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2154 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	2155
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2156 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	2157 if (z == NULL)
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2158 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	2159
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2160 memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit));
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2161 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2162 /* Efficient squaring per HAC, Algorithm 14.16:
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2163 * 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	2164 * 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	2165 * 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	2166 * 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	2167 */
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2168 for (i = 0; i < size_a; ++i) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2169 twodigits carry;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2170 twodigits f = a->ob_digit[i];
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2171 digit *pz = z->ob_digit + (i << 1);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2172 digit *pa = a->ob_digit + i + 1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2173 digit *paend = a->ob_digit + size_a;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2174
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2175 SIGCHECK({
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2176 Py_DECREF(z);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2177 return NULL;
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
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2180 carry = pz + f f;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2181 *pz++ = (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2182 carry >>= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2183 assert(carry <= PyLong_MASK);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2184
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2185 /* 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	2186 * 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	2187 */
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2188 f <<= 1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2189 while (pa < paend) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2190 carry += pz + pa++ * f;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2191 *pz++ = (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2192 carry >>= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2193 assert(carry <= (PyLong_MASK << 1));
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2194 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2195 if (carry) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2196 carry += *pz;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2197 *pz++ = (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2198 carry >>= PyLong_SHIFT;
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2199 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2200 if (carry)
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2201 *pz += (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2202 assert((carry >> PyLong_SHIFT) == 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2203 }
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2204 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2205 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	2206 for (i = 0; i < size_a; ++i) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2207 twodigits carry = 0;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2208 twodigits f = a->ob_digit[i];
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2209 digit *pz = z->ob_digit + i;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2210 digit *pb = b->ob_digit;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2211 digit *pbend = b->ob_digit + size_b;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2212
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2213 SIGCHECK({
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2214 Py_DECREF(z);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2215 return NULL;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2216 })
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2217
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2218 while (pb < pbend) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2219 carry += pz + pb++ * f;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2220 *pz++ = (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2221 carry >>= PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2222 assert(carry <= PyLong_MASK);
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2223 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2224 if (carry)
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2225 *pz += (digit)(carry & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2226 assert((carry >> PyLong_SHIFT) == 0);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2227 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2228 }
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2229 return long_normalize(z);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2230 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2231
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2232 /* 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	2233 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	2234 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	2235 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	2236 the return values are >= 0.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2237 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	2238 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2239 static int
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2240 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	2241 {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2242 PyLongObject hi, lo;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2243 Py_ssize_t size_lo, size_hi;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2244 const Py_ssize_t size_n = ABS(Py_SIZE(n));
24745 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 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	2247 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	2248
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2249 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	2250 return -1;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2251 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	2252 Py_DECREF(hi);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2253 return -1;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2254 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2255
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2256 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	2257 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	2258
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2259 *high = long_normalize(hi);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2260 *low = long_normalize(lo);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2261 return 0;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2262 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2263
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2264 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	2265
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2266 /* 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	2267 * 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	2268 * 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	2269 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2270 static PyLongObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2271 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	2272 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2273 Py_ssize_t asize = ABS(Py_SIZE(a));
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2274 Py_ssize_t bsize = ABS(Py_SIZE(b));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2275 PyLongObject *ah = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2276 PyLongObject *al = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2277 PyLongObject *bh = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2278 PyLongObject *bl = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2279 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	2280 PyLongObject t1, t2, *t3;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2281 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	2282 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	2283
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2284 /* (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	2285 * 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	2286 * Then the original product is
24746 49169d00ab18 k_mul(): Repaired typo in comment. Tim Peters <tim.peters@gmail.com> parents: 24745 diff changeset	2287 * 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	2288 * 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	2289 * 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	2290 */
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2291
24747 19e010f792a3 k_mul(): Repaired another typo in another comment. Tim Peters <tim.peters@gmail.com> parents: 24746 diff changeset	2292 /* 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	2293 * is largest.
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2294 */
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2295 if (asize > bsize) {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2296 t1 = a;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2297 a = b;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2298 b = t1;
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2299
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2300 i = asize;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2301 asize = bsize;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2302 bsize = i;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2303 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2304
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2305 /* 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	2306 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	2307 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	2308 if (asize == 0)
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2309 return _PyLong_New(0);
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2310 else
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2311 return x_mul(a, b);
dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2312 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2313
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2314 /* 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	2315 * 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	2316 * 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	2317 * 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	2318 * 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	2319 */
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2320 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	2321 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	2322
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	2323 /* 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	2324 shift = bsize >> 1;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2325 if (kmul_split(a, shift, &ah, &al) < 0) goto fail;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2326 assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */
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	2327
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2328 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2329 bh = ah;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2330 bl = al;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2331 Py_INCREF(bh);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2332 Py_INCREF(bl);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2333 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2334 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	2335
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	2336 /* 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	2337 * 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	2338 * 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	2339 * 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	2340 * 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	2341 * 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	2342 * 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	2343 * 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	2344 * we're effectively doing unsigned arithmetic mod
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2345 * PyLong_BASE*(sizea + sizeb), and so long as the final* result fits,
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 * 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	2347 * 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	2348 * 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	2349 * 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	2350 */
3d2335094b88 k_mul() and long_mul(): I'm confident that the Karatsuba algorithm is Tim Peters <tim.peters@gmail.com> parents: 24755 diff changeset	2351
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 /* 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	2353 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	2354 if (ret == NULL) goto fail;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2355 #ifdef Py_DEBUG
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2356 /* Fill with trash, to catch reference to uninitialized digits. */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2357 memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2358 #endif
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2359
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	2360 /* 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	2361 if ((t1 = k_mul(ah, bh)) == NULL) goto fail;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2362 assert(Py_SIZE(t1) >= 0);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2363 assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret));
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2364 memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2365 Py_SIZE(t1) * sizeof(digit));
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2366
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2367 /* Zero-out the digits higher than the ahbh copy. /
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2368 i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1);
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2369 if (i)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2370 memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0,
24751 dbf6e563023b x_mul(): This failed to normalize its result. Tim Peters <tim.peters@gmail.com> parents: 24750 diff changeset	2371 i * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2372
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	2373 /* 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	2374 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	2375 Py_DECREF(t1);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2376 goto fail;
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2377 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2378 assert(Py_SIZE(t2) >= 0);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2379 assert(Py_SIZE(t2) <= 2shift); / no overlap with high digits */
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2380 memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2381
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2382 /* Zero out remaining digits. */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2383 i = 2shift - Py_SIZE(t2); / number of uninitialized digits */
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2384 if (i)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2385 memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit));
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2386
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	2387 /* 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	2388 * 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	2389 */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2390 i = Py_SIZE(ret) - shift; /* # digits after shift */
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2391 (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2));
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2392 Py_DECREF(t2);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2393
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2394 (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1));
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2395 Py_DECREF(t1);
c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2396
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	2397 /* 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	2398 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	2399 Py_DECREF(ah);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2400 Py_DECREF(al);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2401 ah = al = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2402
33325 1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2403 if (a == b) {
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2404 t2 = t1;
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2405 Py_INCREF(t2);
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2406 }
1768aff92864 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 29641 diff changeset	2407 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	2408 Py_DECREF(t1);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2409 goto fail;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2410 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2411 Py_DECREF(bh);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2412 Py_DECREF(bl);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2413 bh = bl = NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2414
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2415 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	2416 Py_DECREF(t1);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2417 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	2418 if (t3 == NULL) goto fail;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2419 assert(Py_SIZE(t3) >= 0);
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2420
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	2421 /* 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	2422 * 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	2423 */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2424 (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3));
24755 c88d0848c5c9 k_mul: Rearranged computation for better cache use. Ignored overflow Tim Peters <tim.peters@gmail.com> parents: 24751 diff changeset	2425 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	2426
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2427 return long_normalize(ret);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2428
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2429 fail:
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2430 Py_XDECREF(ret);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2431 Py_XDECREF(ah);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2432 Py_XDECREF(al);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2433 Py_XDECREF(bh);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2434 Py_XDECREF(bl);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2435 return NULL;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2436 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2437
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	2438 /* (*) 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	2439
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	2440 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	2441 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	2442
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	2443 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	2444 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	2445 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	2446 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	2447 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	2448 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	2449
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	2450 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	2451 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	2452 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	2453 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	2454
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	2455 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	2456 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	2457
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	2458 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	2459 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	2460 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	2461
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	2462 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	2463
10a4ec45549d k_mul() comments: In honor of Dijkstra, made the proof that "t3 fits" Tim Peters <tim.peters@gmail.com> parents: 24845 diff changeset	2464 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	2465
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	2466 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	2467 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	2468 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	2469 (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	2470 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	2471 asize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2472 digit is enough to hold 2 bits. This is so since PyLong_SHIFT=15 >= 2. If
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	2473 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	2474 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	2475 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	2476 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	2477
24824 7c91d303c563 k_mul() comments: Simplified the simplified explanation of why ahbh and Tim Peters <tim.peters@gmail.com>* parents: 24821 diff changeset	2478 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	2479 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	2480 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	2481 */
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	2482
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2483 /* 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	2484 * 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	2485 * 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	2486 * 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	2487 * 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	2488 * 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	2489 * 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	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 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	2492 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	2493 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2494 const Py_ssize_t asize = ABS(Py_SIZE(a));
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2495 Py_ssize_t bsize = ABS(Py_SIZE(b));
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2496 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	2497 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	2498 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	2499
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2500 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	2501 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	2502
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2503 /* 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	2504 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	2505 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	2506 return NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2507 memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit));
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2508
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2509 /* 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	2510 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	2511 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	2512 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	2513
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2514 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	2515 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	2516 PyLongObject *product;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2517 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	2518
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2519 /* 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	2520 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	2521 nbtouse * sizeof(digit));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2522 Py_SIZE(bslice) = nbtouse;
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2523 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	2524 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	2525 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	2526
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2527 /* Add into result. */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2528 (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone,
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2529 product->ob_digit, Py_SIZE(product));
24773 801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2530 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	2531
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2532 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	2533 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	2534 }
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2535
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2536 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	2537 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	2538
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2539 fail:
801a44ab2aae Added new function k_lopsided_mul(), which is much more efficient than Tim Peters <tim.peters@gmail.com> parents: 24765 diff changeset	2540 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	2541 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	2542 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	2543 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2544
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2545 static PyObject *
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2546 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	2547 {
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2548 PyLongObject a, b, *z;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2549
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2550 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	2551 Py_INCREF(Py_NotImplemented);
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2552 return Py_NotImplemented;
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2553 }
ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2554
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	2555 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	2556 /* 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	2557 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	2558 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	2559 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	2560 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	2561 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2562 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2563
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2564 /* The / and % operators are now defined in terms of divmod().
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2565 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	2566 The long_divrem function gives the remainder after division of
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2567 \|a\| by \|b\|, with the sign of a. This is also expressed
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2568 as a - b*trunc(a/b), if trunc truncates towards zero.
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2569 Some examples:
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2570 a b a rem b a mod b
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2571 13 10 3 3
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2572 -13 10 -3 7
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2573 13 -10 3 -7
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2574 -13 -10 -3 -3
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2575 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	2576 have different signs. We then subtract one from the 'div'
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2577 part of the outcome to keep the invariant intact. */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2578
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2579 /* Compute
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2580 * pdiv, pmod = divmod(v, w)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2581 * 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	2582 * 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	2583 * 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	2584 */
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2585 static int
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2586 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	2587 PyLongObject pdiv, PyLongObject pmod)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2588 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2589 PyLongObject div, mod;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2590
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2591 if (long_divrem(v, w, &div, &mod) < 0)
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2592 return -1;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2593 if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) \|\|
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2594 (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2595 PyLongObject *temp;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2596 PyLongObject *one;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2597 temp = (PyLongObject *) long_add(mod, w);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2598 Py_DECREF(mod);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2599 mod = temp;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2600 if (mod == NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2601 Py_DECREF(div);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2602 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2603 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2604 one = (PyLongObject *) PyLong_FromLong(1L);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2605 if (one == NULL \|\|
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2606 (temp = (PyLongObject *) long_sub(div, one)) == NULL) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2607 Py_DECREF(mod);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2608 Py_DECREF(div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2609 Py_XDECREF(one);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2610 return -1;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2611 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2612 Py_DECREF(one);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2613 Py_DECREF(div);
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2614 div = temp;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2615 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2616 if (pdiv != NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2617 *pdiv = div;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2618 else
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2619 Py_DECREF(div);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2620
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2621 if (pmod != NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2622 *pmod = mod;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2623 else
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2624 Py_DECREF(mod);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2625
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2626 return 0;
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2627 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2628
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2629 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	2630 long_div(PyObject v, PyObject w)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2631 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2632 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	2633
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2634 CONVERT_BINOP(v, w, &a, &b);
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2635 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	2636 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	2637 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	2638 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2639 return (PyObject *)div;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2640 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2641
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2642 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	2643 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	2644 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2645 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	2646
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2647 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	2648 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	2649 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	2650 div = NULL;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2651 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	2652 div = NULL;
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2653 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	2654 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	2655 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	2656 }
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2657
c0a44829bcd5 Add warning mode for classic division, almost exactly as specified in Guido van Rossum <guido@python.org> parents: 19610 diff changeset	2658 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	2659 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	2660 {
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	2661 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	2662 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	2663 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	2664
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	2665 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	2666 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	2667 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	2668 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	2669 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	2670 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	2671 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	2672 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	2673 /* '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	2674 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	2675 _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	2676 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	2677
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	2678 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	2679 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	2680 "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	2681 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	2682 }
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	2683
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2684 /* True value is very close to ad/bd * 2*(PyLong_SHIFT(aexp-bexp)) */
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	2685 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	2686 aexp -= bexp;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2687 if (aexp > INT_MAX / PyLong_SHIFT)
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	2688 goto overflow;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2689 else if (aexp < -(INT_MAX / PyLong_SHIFT))
19787 f814ea6bb667 long_true_divide: reliably force underflow to 0 when the denominator Tim Peters <tim.peters@gmail.com> parents: 19719 diff changeset	2690 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	2691 errno = 0;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2692 ad = ldexp(ad, aexp * PyLong_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	2693 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	2694 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	2695 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	2696
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	2697 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	2698 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	2699 "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	2700 return NULL;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2701
19675 685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2702 }
685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2703
685dcae5c123 Move long_true_divide next to the other division routines (for clarity!). Tim Peters <tim.peters@gmail.com> parents: 19674 diff changeset	2704 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	2705 long_mod(PyObject v, PyObject w)
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2706 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2707 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	2708
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2709 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	2710
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2711 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	2712 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	2713 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	2714 Py_DECREF(b);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2715 return (PyObject *)mod;
613 405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2716 }
405a2fec7454 Add prototypes. Guido van Rossum <guido@python.org> parents: 590 diff changeset	2717
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2718 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	2719 long_divmod(PyObject v, PyObject w)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2720 {
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 PyLongObject a, b, div, mod;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2722 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	2723
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2724 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	2725
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	2726 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	2727 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	2728 Py_DECREF(b);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2729 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	2730 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2731 z = PyTuple_New(2);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2732 if (z != NULL) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2733 PyTuple_SetItem(z, 0, (PyObject *) div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2734 PyTuple_SetItem(z, 1, (PyObject *) mod);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2735 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2736 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2737 Py_DECREF(div);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2738 Py_DECREF(mod);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2739 }
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	2740 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	2741 Py_DECREF(b);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2742 return z;
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2743 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2744
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2745 /* pow(v, w, x) */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2746 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	2747 long_pow(PyObject v, PyObject w, PyObject *x)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2748 {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2749 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	2750 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	2751
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2752 PyLongObject z = NULL; / accumulated result */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2753 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	2754 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	2755
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2756 /* 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	2757 * 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	2758 */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2759 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	2760 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	2761
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2762 /* 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	2763 CONVERT_BINOP(v, w, &a, &b);
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2764 if (PyLong_Check(x)) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2765 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	2766 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	2767 }
35254 d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2768 else if (PyInt_Check(x)) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2769 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	2770 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	2771 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	2772 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2773 else if (x == Py_None)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2774 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	2775 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	2776 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	2777 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	2778 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	2779 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	2780 }
19719 cdfdd5359411 Make the error msgs in our pow() implementations consistent. Tim Peters <tim.peters@gmail.com> parents: 19717 diff changeset	2781
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2782 if (Py_SIZE(b) < 0) { /* if exponent is negative */
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2783 if (c) {
19719 cdfdd5359411 Make the error msgs in our pow() implementations consistent. Tim Peters <tim.peters@gmail.com> parents: 19717 diff changeset	2784 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	2785 "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	2786 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	2787 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2788 else {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2789 /* 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	2790 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	2791 arguments to double. */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2792 Py_DECREF(a);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2793 Py_DECREF(b);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2794 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	2795 }
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2796 }
33327 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 if (c) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2799 /* if modulus == 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2800 raise ValueError() */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2801 if (Py_SIZE(c) == 0) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2802 PyErr_SetString(PyExc_ValueError,
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2803 "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	2804 goto Error;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2805 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2806
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2807 /* if modulus < 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2808 negativeOutput = True
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2809 modulus = -modulus */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2810 if (Py_SIZE(c) < 0) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2811 negativeOutput = 1;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2812 temp = (PyLongObject *)_PyLong_Copy(c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2813 if (temp == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2814 goto Error;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2815 Py_DECREF(c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2816 c = temp;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2817 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2818 c->ob_size = - c->ob_size;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2819 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2820
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2821 /* if modulus == 1:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2822 return 0 */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2823 if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2824 z = (PyLongObject *)PyLong_FromLong(0L);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2825 goto Done;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2826 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2827
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2828 /* if base < 0:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2829 base = base % modulus
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2830 Having the base positive just makes things easier. */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2831 if (Py_SIZE(a) < 0) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2832 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	2833 goto Error;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2834 Py_DECREF(a);
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2835 a = temp;
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2836 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2837 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2838 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2839
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2840 /* 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	2841 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	2842
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2843 z = (PyLongObject *)PyLong_FromLong(1L);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2844 if (z == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2845 goto Error;
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 /* 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	2848 * is NULL.
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 #define REDUCE(X) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2851 if (c != NULL) { \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2852 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	2853 goto Error; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2854 Py_XDECREF(X); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2855 X = temp; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2856 temp = NULL; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2857 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2858
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2859 /* Multiply two values, then reduce the result:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2860 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	2861 #define MULT(X, Y, result) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2862 { \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2863 temp = (PyLongObject *)long_mul(X, Y); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2864 if (temp == NULL) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2865 goto Error; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2866 Py_XDECREF(result); \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2867 result = temp; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2868 temp = NULL; \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2869 REDUCE(result) \
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2870 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2871
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2872 if (Py_SIZE(b) <= FIVEARY_CUTOFF) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2873 /* 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	2874 /* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2875 for (i = Py_SIZE(b) - 1; i >= 0; --i) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2876 digit bi = b->ob_digit[i];
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2877
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2878 for (j = 1 << (PyLong_SHIFT-1); j != 0; j >>= 1) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2879 MULT(z, z, z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2880 if (bi & j)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2881 MULT(z, a, z)
250 b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2882 }
b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2883 }
b9986009d7dc Fix off-by-one error in long_repr. Guido van Rossum <guido@python.org> parents: 242 diff changeset	2884 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2885 else {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2886 /* 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	2887 Py_INCREF(z); /* still holds 1L */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2888 table[0] = z;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2889 for (i = 1; i < 32; ++i)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2890 MULT(table[i-1], a, table[i])
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2891
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2892 for (i = Py_SIZE(b) - 1; i >= 0; --i) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2893 const digit bi = b->ob_digit[i];
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2894
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	2895 for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2896 const int index = (bi >> j) & 0x1f;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2897 for (k = 0; k < 5; ++k)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2898 MULT(z, z, z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2899 if (index)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2900 MULT(z, table[index], z)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2901 }
11380 3e3c71f4d2de Fix PR#66. Solution: add error checking around l_divmod() calls in Guido van Rossum <guido@python.org> parents: 11331 diff changeset	2902 }
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	2903 }
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2904
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2905 if (negativeOutput && (Py_SIZE(z) != 0)) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2906 temp = (PyLongObject *)long_sub(z, c);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2907 if (temp == NULL)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2908 goto Error;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2909 Py_DECREF(z);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2910 z = temp;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2911 temp = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2912 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2913 goto Done;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2914
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2915 Error:
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2916 if (z != NULL) {
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2917 Py_DECREF(z);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2918 z = NULL;
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2919 }
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2920 /* fall through */
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2921 Done:
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2922 if (Py_SIZE(b) > FIVEARY_CUTOFF) {
33327 5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2923 for (i = 0; i < 32; ++i)
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2924 Py_XDECREF(table[i]);
5452d4ecddd0 SF patch 936813: fast modular exponentiation Tim Peters <tim.peters@gmail.com> parents: 33325 diff changeset	2925 }
35254 d61efcd87c8e SF bug #1238681: freed pointer is used in longobject.c:long_pow(). Tim Peters <tim.peters@gmail.com> parents: 35177 diff changeset	2926 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	2927 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	2928 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	2929 Py_XDECREF(temp);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2930 return (PyObject *)z;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2931 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2932
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2933 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	2934 long_invert(PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2935 {
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	2936 /* Implement ~x as -(x+1) */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2937 PyLongObject *x;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2938 PyLongObject *w;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2939 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	2940 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	2941 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2942 x = (PyLongObject *) long_add(v, w);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2943 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	2944 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	2945 return NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2946 Py_SIZE(x) = -(Py_SIZE(x));
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2947 return (PyObject *)x;
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2948 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2949
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2950 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	2951 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	2952 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2953 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	2954 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	2955 /* -0 == 0 */
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2956 Py_INCREF(v);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2957 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	2958 }
19880 d1cd4cd72271 More bug 460020. Disable a number of long optimizations for long subclasses. Tim Peters <tim.peters@gmail.com> parents: 19837 diff changeset	2959 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	2960 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	2961 z->ob_size = -(v->ob_size);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2962 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	2963 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2964
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2965 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	2966 long_abs(PyLongObject *v)
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2967 {
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2968 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	2969 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	2970 else
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	2971 return long_long((PyObject *)v);
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2972 }
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2973
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2974 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	2975 long_nonzero(PyLongObject *v)
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	2976 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2977 return ABS(Py_SIZE(v)) != 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	2978 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	2979
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2980 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	2981 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	2982 {
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	2983 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	2984 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	2985 long shiftby;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	2986 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	2987 digit lomask, himask;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2988
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	2989 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	2990
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	2991 if (Py_SIZE(a) < 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	2992 /* 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	2993 PyLongObject a1, a2;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2994 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	2995 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	2996 goto rshift_error;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2997 a2 = (PyLongObject *) long_rshift(a1, b);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	2998 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	2999 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	3000 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	3001 z = (PyLongObject *) long_invert(a2);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3002 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	3003 }
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	3004 else {
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3005
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	3006 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	3007 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	3008 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	3009 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	3010 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	3011 "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	3012 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	3013 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3014 wordshift = shiftby / PyLong_SHIFT;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3015 newsize = ABS(Py_SIZE(a)) - wordshift;
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 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	3017 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	3018 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	3019 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	3020 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	3021 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3022 loshift = shiftby % PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3023 hishift = PyLong_SHIFT - loshift;
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	3024 lomask = ((digit)1 << hishift) - 1;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3025 himask = PyLong_MASK ^ lomask;
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 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	3027 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	3028 goto rshift_error;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3029 if (Py_SIZE(a) < 0)
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3030 Py_SIZE(z) = -(Py_SIZE(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	3031 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	3032 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	3033 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	3034 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	3035 (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	3036 }
8e402aeca0a3 Make long a new style number type. Sequence repeat is now done here Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15318 diff changeset	3037 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	3038 }
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	3039 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	3040 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	3041 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	3042 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	3043
443 9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3044 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3045
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3046 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	3047 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	3048 {
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	3049 /* 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	3050 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	3051 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	3052 long shiftby;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3053 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	3054 twodigits accum;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3055
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	3056 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	3057
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3058 shiftby = PyLong_AsLong((PyObject *)b);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3059 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	3060 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	3061 if (shiftby < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3062 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	3063 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	3064 }
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	3065 if ((long)(int)shiftby != shiftby) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3066 PyErr_SetString(PyExc_ValueError,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3067 "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	3068 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	3069 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3070 /* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3071 wordshift = (int)shiftby / PyLong_SHIFT;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3072 remshift = (int)shiftby - wordshift * PyLong_SHIFT;
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	3073
7e380df00d00 New long_lshift, without restriction on size of shift count, by Tim Peters. Guido van Rossum <guido@python.org> parents: 5197 diff changeset	3074 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	3075 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	3076 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	3077 ++newsize;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3078 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	3079 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	3080 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	3081 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	3082 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	3083 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	3084 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	3085 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	3086 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	3087 accum \|= (twodigits)a->ob_digit[j] << remshift;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3088 z->ob_digit[i] = (digit)(accum & PyLong_MASK);
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3089 accum >>= PyLong_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	3090 }
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	3091 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	3092 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	3093 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	3094 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	3095 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	3096 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	3097 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	3098 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	3099 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	3100 }
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
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3103 /* 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	3104
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3105 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	3106 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	3107 int op, /* '&', '\|', '^' */
a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3108 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	3109 {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3110 digit maska, maskb; /* 0 or PyLong_MASK */
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3111 int negz;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3112 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	3113 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	3114 int i;
743 dbcb49d742a0 Lint stuff (involves casts, yuck!) Guido van Rossum <guido@python.org> parents: 613 diff changeset	3115 digit diga, digb;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3116 PyObject *v;
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3117
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3118 if (Py_SIZE(a) < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3119 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	3120 if (a == NULL)
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3121 return NULL;
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3122 maska = PyLong_MASK;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3123 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3124 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3125 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	3126 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	3127 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3128 if (Py_SIZE(b) < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3129 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	3130 if (b == NULL) {
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3131 Py_DECREF(a);
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3132 return NULL;
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36675 diff changeset	3133 }
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3134 maskb = PyLong_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	3135 }
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3136 else {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3137 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	3138 maskb = 0;
546 937cbc0be6ec Fixed bug in long masking ops. Guido van Rossum <guido@python.org> parents: 475 diff changeset	3139 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3140
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3141 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	3142 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	3143 case '^':
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3144 if (maska != maskb) {
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3145 maska ^= PyLong_MASK;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3146 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	3147 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3148 break;
1837 87364d9e3444 New patches by Andrew to fix various problems Guido van Rossum <guido@python.org> parents: 1391 diff changeset	3149 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	3150 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	3151 op = '\|';
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3152 maska ^= PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3153 maskb ^= PyLong_MASK;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3154 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	3155 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3156 break;
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3157 case '\|':
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3158 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	3159 op = '&';
44945 bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3160 maska ^= PyLong_MASK;
bbc719a8b58b Backport of several functions from Python 3.0 to 2.6 including PyUnicode_FromString, PyUnicode_Format and PyLong_From/AsSsize_t. The functions are partly required for the backport of the bytearray type and _fileio module. They should also make it easier to port C to 3.0. Christian Heimes <christian@cheimes.de> parents: 44749 diff changeset	3161 maskb ^= PyLong_MASK;
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3162 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	3163 }
f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3164 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	3165 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3166
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3167 /* 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	3168 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	3169 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	3170 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	3171 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	3172 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	3173 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	3174 whose length should be ignored.
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3175 */
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3176
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3177 size_a = Py_SIZE(a);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3178 size_b = Py_SIZE(b);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3179 size_z = op == '&'
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3180 ? (maska
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3181 ? size_b
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3182 : (maskb ? size_a : MIN(size_a, size_b)))
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3183 : MAX(size_a, size_b);
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3184 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	3185 if (z == NULL) {
39095 bda93b45ca41 a & b were dereffed above, so they are known to be valid pointers. Neal Norwitz <nnorwitz@gmail.com> parents: 38513 diff changeset	3186 Py_DECREF(a);
bda93b45ca41 a & b were dereffed above, so they are known to be valid pointers. Neal Norwitz <nnorwitz@gmail.com> parents: 38513 diff changeset	3187 Py_DECREF(b);
8933 dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3188 return NULL;
dc6edfd4bae5 Two patches by Jason Harper: Guido van Rossum <guido@python.org> parents: 8822 diff changeset	3189 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3190
590 f11fae8ee1e4 Changed to 2's complement bitwise ops. Got rid of ZABS etc. Guido van Rossum <guido@python.org> parents: 546 diff changeset	3191 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	3192 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	3193 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	3194 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	3195 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	3196 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	3197 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	3198 }
546 937cbc0be6ec Fixed bug in long masking ops. Guido van Rossum <guido@python.org> parents: 475 diff changeset	3199 }
24745 ba035f4b47c1 Cautious introduction of a patch that started from Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	3200
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3201 Py_DECREF(a);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3202 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	3203 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	3204 if (negz == 0)
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3205 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	3206 v = long_invert(z);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3207 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	3208 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	3209 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3210
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3211 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	3212 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	3213 {
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	3214 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	3215 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	3216 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	3217 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	3218 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	3219 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	3220 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	3221 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3222
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3223 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	3224 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	3225 {
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	3226 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	3227 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	3228 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	3229 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	3230 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	3231 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	3232 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	3233 }
9f85beb1f7c8 Made the sign use one's complement; implemented shifting and masking operators. Guido van Rossum <guido@python.org> parents: 406 diff changeset	3234
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3235 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	3236 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	3237 {
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	3238 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	3239 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	3240 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	3241 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	3242 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	3243 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	3244 return c;
242 316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	3245 }
316a0d9c0096 Many small changes Guido van Rossum <guido@python.org> parents: 230 diff changeset	3246
1313 6ee380349c84 * Added gmtime/localtime/mktime and SYSV timezone globals to timemodule.c. Guido van Rossum <guido@python.org> parents: 1257 diff changeset	3247 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	3248 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	3249 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3250 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	3251 pw = PyLong_FromLong(PyInt_AS_LONG(pw));
41435 46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	3252 if (*pw == NULL)
46d0f4057705 Add some missing NULL checks which trigger crashes on low-memory conditions. Georg Brandl <georg@python.org> parents: 41032 diff changeset	3253 return -1;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3254 Py_INCREF(*pv);
955 03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3255 return 0;
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3256 }
19976 da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3257 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	3258 Py_INCREF(*pv);
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3259 Py_INCREF(*pw);
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3260 return 0;
da00188d5270 Add additional coercion support for "self subtypes" to int, long, Guido van Rossum <guido@python.org> parents: 19925 diff changeset	3261 }
955 03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3262 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	3263 }
03de67080c95 * classobject.[ch], {float,long,int}object.c, bltinmodule.c: Guido van Rossum <guido@python.org> parents: 795 diff changeset	3264
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3265 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	3266 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	3267 {
34931 9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3268 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	3269 Py_INCREF(v);
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3270 else
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 34666 diff changeset	3271 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	3272 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	3273 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3274
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3275 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	3276 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	3277 {
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3278 long x;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3279 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	3280 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	3281 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	3282 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	3283 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	3284 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	3285 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	3286 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3287 else
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3288 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	3289 }
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3290 else
d31ddc66b1b5 Change int() so that passing a string, unicode, float or long argument Walter Dörwald <walter@livinglogic.de> parents: 26081 diff changeset	3291 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	3292 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3293 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	3294 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3295
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3296 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	3297 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	3298 {
5118 002865af55e5 Changes for Lee Busby's SIGFPE patch set. Guido van Rossum <guido@python.org> parents: 4870 diff changeset	3299 double result;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3300 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	3301 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	3302 return NULL;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3303 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	3304 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3305
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3306 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	3307 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	3308 {
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	3309 return _PyLong_Format(v, 8, 1, 0);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3310 }
2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3311
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3312 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	3313 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	3314 {
45262 86906a5ceca6 Added PyNumber_ToBase and supporting routines _PyInt_Format and Eric Smith <eric@trueblade.com> parents: 44945 diff changeset	3315 return _PyLong_Format(v, 16, 1, 0);
1049 2ed511171809 Made builtins int(), long(), float(), oct() and hex() more generic. Guido van Rossum <guido@python.org> parents: 958 diff changeset	3316 }
24280 1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24231 diff changeset	3317
1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24231 diff changeset	3318 static PyObject *
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3319 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	3320
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3321 static PyObject *
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3322 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	3323 {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3324 PyObject *x = NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3325 int base = -909; /* unlikely! */
36675 dba6494735d0 Revert backwards-incompatible const changes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	3326 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	3327
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3328 if (type != &PyLong_Type)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3329 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	3330 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	3331 &x, &base))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3332 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3333 if (x == NULL)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3334 return PyLong_FromLong(0L);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3335 if (base == -909)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3336 return PyNumber_Long(x);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	3337 else if (PyString_Check(x)) {
41032 6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3338 /* Since PyLong_FromString doesn't have a length parameter,
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3339 * check here for possible NULs in the string. */
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	3340 char *string = PyString_AS_STRING(x);
52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	3341 if (strlen(string) != PyString_Size(x)) {
41032 6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3342 /* create a repr() of the input string,
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3343 * just like PyLong_FromString does. */
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3344 PyObject *srepr;
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3345 srepr = PyObject_Repr(x);
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3346 if (srepr == NULL)
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3347 return NULL;
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3348 PyErr_Format(PyExc_ValueError,
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3349 "invalid literal for long() with base %d: %s",
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	3350 base, PyString_AS_STRING(srepr));
41032 6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3351 Py_DECREF(srepr);
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3352 return NULL;
6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3353 }
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47421 diff changeset	3354 return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
41032 6a599aee7ca4 Patch #1638879: don't accept strings with embedded NUL bytes in long(). Georg Brandl <georg@python.org> parents: 40908 diff changeset	3355 }
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	3356 #ifdef Py_USING_UNICODE
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3357 else if (PyUnicode_Check(x))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3358 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	3359 PyUnicode_GET_SIZE(x),
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3360 base);
19343 7257e87e0720 Patch #445762: Support --disable-unicode Martin v. Löwis <martin@v.loewis.de> parents: 19051 diff changeset	3361 #endif
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3362 else {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3363 PyErr_SetString(PyExc_TypeError,
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3364 "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	3365 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3366 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3367 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3368
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3369 /* 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	3370 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	3371 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	3372 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	3373 */
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3374 static PyObject *
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3375 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	3376 {
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3377 PyLongObject tmp, newobj;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36430 diff changeset	3378 Py_ssize_t i, n;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3379
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3380 assert(PyType_IsSubtype(type, &PyLong_Type));
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3381 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	3382 if (tmp == NULL)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3383 return NULL;
19837 5158e4789459 SF bug #460020: bug or feature: unicode() and subclasses. Tim Peters <tim.peters@gmail.com> parents: 19787 diff changeset	3384 assert(PyLong_CheckExact(tmp));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3385 n = Py_SIZE(tmp);
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3386 if (n < 0)
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3387 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	3388 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	3389 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	3390 Py_DECREF(tmp);
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3391 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	3392 }
37589 aeee85b6a5dd More C++-compliance. Note especially listobject.c - to get C++ to accept the Anthony Baxter <anthonybaxter@gmail.com> parents: 37568 diff changeset	3393 assert(PyLong_Check(newobj));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 43406 diff changeset	3394 Py_SIZE(newobj) = Py_SIZE(tmp);
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3395 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	3396 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	3397 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	3398 return (PyObject *)newobj;
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3399 }
6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3400
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3401 static PyObject *
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3402 long_getnewargs(PyLongObject *v)
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3403 {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3404 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	3405 }
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3406
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3407 static PyObject *
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3408 long_getN(PyLongObject v, void context) {
45815 8a3fa86c30a6 Fix build on platforms that don't have intptr_t. Patch by Joseph Armbruster. Jeffrey Yasskin <jyasskin@gmail.com> parents: 45791 diff changeset	3409 return PyLong_FromLong((Py_intptr_t)context);
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3410 }
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3411
45381 b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3412 static PyObject *
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3413 long__format__(PyObject self, PyObject args)
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3414 {
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3415 PyObject *format_spec;
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3416
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3417 if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3418 return NULL;
47294 4fe192d48960 Renamed PyString to PyBytes Christian Heimes <christian@cheimes.de> parents: 46473 diff changeset	3419 if (PyBytes_Check(format_spec))
47392 47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3420 return _PyLong_FormatAdvanced(self,
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3421 PyBytes_AS_STRING(format_spec),
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3422 PyBytes_GET_SIZE(format_spec));
45381 b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3423 if (PyUnicode_Check(format_spec)) {
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3424 /* Convert format_spec to a str */
47392 47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3425 PyObject *result;
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3426 PyObject *str_spec = PyObject_Str(format_spec);
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3427
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3428 if (str_spec == NULL)
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3429 return NULL;
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3430
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3431 result = _PyLong_FormatAdvanced(self,
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3432 PyBytes_AS_STRING(str_spec),
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3433 PyBytes_GET_SIZE(str_spec));
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3434
47ef9a806ce9 Refactor and clean up str.format() code (and helpers) in advance of optimizations. Eric Smith <eric@trueblade.com> parents: 47294 diff changeset	3435 Py_DECREF(str_spec);
45381 b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3436 return result;
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3437 }
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3438 PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode");
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3439 return NULL;
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3440 }
b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3441
47419 88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3442 static PyObject *
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3443 long_sizeof(PyLongObject *v)
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3444 {
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3445 Py_ssize_t res;
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3446
47922 7cfc28ac0715 Added additional __sizeof__ implementations and addressed comments made in Robert Schuppenies <okkotonushi@googlemail.com> parents: 47822 diff changeset	3447 res = v->ob_type->tp_basicsize;
47419 88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3448 if (v->ob_size != 0)
47922 7cfc28ac0715 Added additional __sizeof__ implementations and addressed comments made in Robert Schuppenies <okkotonushi@googlemail.com> parents: 47822 diff changeset	3449 res += abs(v->ob_size) * sizeof(digit);
47419 88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3450 return PyInt_FromSsize_t(res);
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3451 }
88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3452
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3453 #if 0
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3454 static PyObject *
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3455 long_is_finite(PyObject *v)
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3456 {
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3457 Py_RETURN_TRUE;
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3458 }
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3459 #endif
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3460
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3461 static PyMethodDef long_methods[] = {
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3462 {"conjugate", (PyCFunction)long_long, METH_NOARGS,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3463 "Returns self, the complex conjugate of any long."},
46473 5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3464 #if 0
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3465 {"is_finite", (PyCFunction)long_is_finite, METH_NOARGS,
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3466 "Returns always True."},
5bc7b20dc04a I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. Christian Heimes <christian@cheimes.de> parents: 46459 diff changeset	3467 #endif
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3468 {"__trunc__", (PyCFunction)long_long, METH_NOARGS,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3469 "Truncating an Integral returns itself."},
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3470 {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS},
45381 b7231bf6bfb7 Backport of PEP 3101, Advanced String Formatting, from py3k. Eric Smith <eric@trueblade.com> parents: 45262 diff changeset	3471 {"__format__", (PyCFunction)long__format__, METH_VARARGS},
47419 88bd07c0a847 Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47392 diff changeset	3472 {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS,
47421 a65f095b27f3 Some style nits. Also clarify in the docstrings what __sizeof__ does. Georg Brandl <georg@python.org> parents: 47419 diff changeset	3473 "Returns size in memory, in bytes"},
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3474 {NULL, NULL} /* sentinel */
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3475 };
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3476
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3477 static PyGetSetDef long_getset[] = {
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3478 {"real",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3479 (getter)long_long, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3480 "the real part of a complex number",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3481 NULL},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3482 {"imag",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3483 (getter)long_getN, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3484 "the imaginary part of a complex number",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3485 (void*)0},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3486 {"numerator",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3487 (getter)long_long, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3488 "the numerator of a rational number in lowest terms",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3489 NULL},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3490 {"denominator",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3491 (getter)long_getN, (setter)NULL,
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3492 "the denominator of a rational number in lowest terms",
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3493 (void*)1},
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3494 {NULL} /* Sentinel */
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3495 };
4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3496
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23248 diff changeset	3497 PyDoc_STRVAR(long_doc,
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3498 "long(x[, base]) -> integer\n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3499 \n\
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3500 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	3501 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	3502 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	3503 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	3504 converting a non-string.");
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3505
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3506 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	3507 (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	3508 (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	3509 (binaryfunc) long_mul, /nb_multiply/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3510 long_classic_div, /nb_divide/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3511 long_mod, /nb_remainder/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3512 long_divmod, /nb_divmod/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3513 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	3514 (unaryfunc) long_neg, /nb_negative/
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3515 (unaryfunc) long_long, /tp_positive/
13406 a503af7e7fb7 Some cleanup of longs in prepartion for Cray J90 fixes: got Tim Peters <tim.peters@gmail.com> parents: 13256 diff changeset	3516 (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	3517 (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	3518 (unaryfunc) long_invert, /nb_invert/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3519 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	3520 (binaryfunc) long_rshift, /nb_rshift/
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3521 long_and, /nb_and/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3522 long_xor, /nb_xor/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3523 long_or, /nb_or/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3524 long_coerce, /nb_coerce/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3525 long_int, /nb_int/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3526 long_long, /nb_long/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3527 long_float, /nb_float/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3528 long_oct, /nb_oct/
79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3529 long_hex, /nb_hex/
19051 f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3530 0, /* nb_inplace_add */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3531 0, /* nb_inplace_subtract */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3532 0, /* nb_inplace_multiply */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3533 0, /* nb_inplace_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3534 0, /* nb_inplace_remainder */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3535 0, /* nb_inplace_power */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3536 0, /* nb_inplace_lshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3537 0, /* nb_inplace_rshift */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3538 0, /* nb_inplace_and */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3539 0, /* nb_inplace_xor */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3540 0, /* nb_inplace_or */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3541 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	3542 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	3543 0, /* nb_inplace_floor_divide */
f20727cc3d0f Implement PEP 238 in its (almost) full glory. Guido van Rossum <guido@python.org> parents: 18933 diff changeset	3544 0, /* nb_inplace_true_divide */
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39141 diff changeset	3545 long_long, /* nb_index */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3546 };
7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3547
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3548 PyTypeObject PyLong_Type = {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 5288 diff changeset	3549 PyObject_HEAD_INIT(&PyType_Type)
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3550 0, /* ob_size */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3551 "long", /* tp_name */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3552 sizeof(PyLongObject) - sizeof(digit), /* tp_basicsize */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3553 sizeof(digit), /* tp_itemsize */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3554 long_dealloc, /* tp_dealloc */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3555 0, /* tp_print */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3556 0, /* tp_getattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3557 0, /* tp_setattr */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3558 (cmpfunc)long_compare, /* tp_compare */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3559 long_repr, /* tp_repr */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3560 &long_as_number, /* tp_as_number */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3561 0, /* tp_as_sequence */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3562 0, /* tp_as_mapping */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3563 (hashfunc)long_hash, /* tp_hash */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3564 0, /* tp_call */
37304 79a0f080f898 Remove unnecessary casts in type object initializers. Georg Brandl <georg@python.org> parents: 37288 diff changeset	3565 long_str, /* tp_str */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3566 PyObject_GenericGetAttr, /* tp_getattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3567 0, /* tp_setattro */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3568 0, /* tp_as_buffer */
19552 6c30d20d27f2 Make int, long and float subclassable. Guido van Rossum <guido@python.org> parents: 19343 diff changeset	3569 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_CHECKTYPES \|
40908 d01bd37bf5ce Variation of patch # 1624059 to speed up checking if an object is a subclass Neal Norwitz <nnorwitz@gmail.com> parents: 39995 diff changeset	3570 Py_TPFLAGS_BASETYPE \| Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3571 long_doc, /* tp_doc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3572 0, /* tp_traverse */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3573 0, /* tp_clear */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3574 0, /* tp_richcompare */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3575 0, /* tp_weaklistoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3576 0, /* tp_iter */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3577 0, /* tp_iternext */
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 27487 diff changeset	3578 long_methods, /* tp_methods */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3579 0, /* tp_members */
44432 4f9723d9ca32 Backport PEP 3141 from the py3k branch to the trunk. This includes r50877 (just Jeffrey Yasskin <jyasskin@gmail.com> parents: 44350 diff changeset	3580 long_getset, /* tp_getset */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3581 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3582 0, /* tp_dict */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3583 0, /* tp_descr_get */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3584 0, /* tp_descr_set */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3585 0, /* tp_dictoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3586 0, /* tp_init */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3587 0, /* tp_alloc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18607 diff changeset	3588 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	3589 PyObject_Del, /* tp_free */
230 7ba9612058a4 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3590 };

Mercurial > cpython-lru_cache-weakref

annotate Objects/longobject.c @ 58925:eecf1bef052d 2.6