diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Objects/intobject.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Objects/intobject.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,1403 @@ + +/* Integer object implementation */ + +#include "Python.h" +#include + +static PyObject *int_int(PyIntObject *v); + +long +PyInt_GetMax(void) +{ + return LONG_MAX; /* To initialize sys.maxint */ +} + +/* Integers are quite normal objects, to make object handling uniform. + (Using odd pointers to represent integers would save much space + but require extra checks for this special case throughout the code.) + Since a typical Python program spends much of its time allocating + and deallocating integers, these operations should be very fast. + Therefore we use a dedicated allocation scheme with a much lower + overhead (in space and time) than straight malloc(): a simple + dedicated free list, filled when necessary with memory from malloc(). + + block_list is a singly-linked list of all PyIntBlocks ever allocated, + linked via their next members. PyIntBlocks are never returned to the + system before shutdown (PyInt_Fini). + + free_list is a singly-linked list of available PyIntObjects, linked + via abuse of their ob_type members. +*/ + +#define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */ +#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */ +#define N_INTOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject)) + +struct _intblock { + struct _intblock *next; + PyIntObject objects[N_INTOBJECTS]; +}; + +typedef struct _intblock PyIntBlock; + +static PyIntBlock *block_list = NULL; +static PyIntObject *free_list = NULL; + +static PyIntObject * +fill_free_list(void) +{ + PyIntObject *p, *q; + /* Python's object allocator isn't appropriate for large blocks. */ + p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock)); + if (p == NULL) + return (PyIntObject *) PyErr_NoMemory(); + ((PyIntBlock *)p)->next = block_list; + block_list = (PyIntBlock *)p; + /* Link the int objects together, from rear to front, then return + the address of the last int object in the block. */ + p = &((PyIntBlock *)p)->objects[0]; + q = p + N_INTOBJECTS; + while (--q > p) + Py_TYPE(q) = (struct _typeobject *)(q-1); + Py_TYPE(q) = NULL; + return p + N_INTOBJECTS - 1; +} + +#ifndef NSMALLPOSINTS +#define NSMALLPOSINTS 257 +#endif +#ifndef NSMALLNEGINTS +#define NSMALLNEGINTS 5 +#endif +#if NSMALLNEGINTS + NSMALLPOSINTS > 0 +/* References to small integers are saved in this array so that they + can be shared. + The integers that are saved are those in the range + -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive). +*/ +static PyIntObject *small_ints[NSMALLNEGINTS + NSMALLPOSINTS]; +#endif +#ifdef COUNT_ALLOCS +int quick_int_allocs, quick_neg_int_allocs; +#endif + +PyObject * +PyInt_FromLong(long ival) +{ + register PyIntObject *v; +#if NSMALLNEGINTS + NSMALLPOSINTS > 0 + if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { + v = small_ints[ival + NSMALLNEGINTS]; + Py_INCREF(v); +#ifdef COUNT_ALLOCS + if (ival >= 0) + quick_int_allocs++; + else + quick_neg_int_allocs++; +#endif + return (PyObject *) v; + } +#endif + if (free_list == NULL) { + if ((free_list = fill_free_list()) == NULL) + return NULL; + } + /* Inline PyObject_New */ + v = free_list; + free_list = (PyIntObject *)Py_TYPE(v); + PyObject_INIT(v, &PyInt_Type); + v->ob_ival = ival; + return (PyObject *) v; +} + +PyObject * +PyInt_FromSize_t(size_t ival) +{ + if (ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + return _PyLong_FromSize_t(ival); +} + +PyObject * +PyInt_FromSsize_t(Py_ssize_t ival) +{ + if (ival >= LONG_MIN && ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + return _PyLong_FromSsize_t(ival); +} + +static void +int_dealloc(PyIntObject *v) +{ + if (PyInt_CheckExact(v)) { + Py_TYPE(v) = (struct _typeobject *)free_list; + free_list = v; + } + else + Py_TYPE(v)->tp_free((PyObject *)v); +} + +static void +int_free(PyIntObject *v) +{ + Py_TYPE(v) = (struct _typeobject *)free_list; + free_list = v; +} + +long +PyInt_AsLong(register PyObject *op) +{ + PyNumberMethods *nb; + PyIntObject *io; + long val; + + if (op && PyInt_Check(op)) + return PyInt_AS_LONG((PyIntObject*) op); + + if (op == NULL || (nb = Py_TYPE(op)->tp_as_number) == NULL || + nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return -1; + } + + io = (PyIntObject*) (*nb->nb_int) (op); + if (io == NULL) + return -1; + if (!PyInt_Check(io)) { + if (PyLong_Check(io)) { + /* got a long? => retry int conversion */ + val = PyLong_AsLong((PyObject *)io); + Py_DECREF(io); + if ((val == -1) && PyErr_Occurred()) + return -1; + return val; + } + else + { + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return -1; + } + } + + val = PyInt_AS_LONG(io); + Py_DECREF(io); + + return val; +} + +Py_ssize_t +PyInt_AsSsize_t(register PyObject *op) +{ +#if SIZEOF_SIZE_T != SIZEOF_LONG + PyNumberMethods *nb; + PyIntObject *io; + Py_ssize_t val; +#endif + + if (op == NULL) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return -1; + } + + if (PyInt_Check(op)) + return PyInt_AS_LONG((PyIntObject*) op); + if (PyLong_Check(op)) + return _PyLong_AsSsize_t(op); +#if SIZEOF_SIZE_T == SIZEOF_LONG + return PyInt_AsLong(op); +#else + + if ((nb = Py_TYPE(op)->tp_as_number) == NULL || + (nb->nb_int == NULL && nb->nb_long == 0)) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return -1; + } + + if (nb->nb_long != 0) + io = (PyIntObject*) (*nb->nb_long) (op); + else + io = (PyIntObject*) (*nb->nb_int) (op); + if (io == NULL) + return -1; + if (!PyInt_Check(io)) { + if (PyLong_Check(io)) { + /* got a long? => retry int conversion */ + val = _PyLong_AsSsize_t((PyObject *)io); + Py_DECREF(io); + if ((val == -1) && PyErr_Occurred()) + return -1; + return val; + } + else + { + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return -1; + } + } + + val = PyInt_AS_LONG(io); + Py_DECREF(io); + + return val; +#endif +} + +unsigned long +PyInt_AsUnsignedLongMask(register PyObject *op) +{ + PyNumberMethods *nb; + PyIntObject *io; + unsigned long val; + + if (op && PyInt_Check(op)) + return PyInt_AS_LONG((PyIntObject*) op); + if (op && PyLong_Check(op)) + return PyLong_AsUnsignedLongMask(op); + + if (op == NULL || (nb = Py_TYPE(op)->tp_as_number) == NULL || + nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return (unsigned long)-1; + } + + io = (PyIntObject*) (*nb->nb_int) (op); + if (io == NULL) + return (unsigned long)-1; + if (!PyInt_Check(io)) { + if (PyLong_Check(io)) { + val = PyLong_AsUnsignedLongMask((PyObject *)io); + Py_DECREF(io); + if (PyErr_Occurred()) + return (unsigned long)-1; + return val; + } + else + { + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return (unsigned long)-1; + } + } + + val = PyInt_AS_LONG(io); + Py_DECREF(io); + + return val; +} + +#ifdef HAVE_LONG_LONG +unsigned PY_LONG_LONG +PyInt_AsUnsignedLongLongMask(register PyObject *op) +{ + PyNumberMethods *nb; + PyIntObject *io; + unsigned PY_LONG_LONG val; + + if (op && PyInt_Check(op)) + return PyInt_AS_LONG((PyIntObject*) op); + if (op && PyLong_Check(op)) + return PyLong_AsUnsignedLongLongMask(op); + + if (op == NULL || (nb = Py_TYPE(op)->tp_as_number) == NULL || + nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return (unsigned PY_LONG_LONG)-1; + } + + io = (PyIntObject*) (*nb->nb_int) (op); + if (io == NULL) + return (unsigned PY_LONG_LONG)-1; + if (!PyInt_Check(io)) { + if (PyLong_Check(io)) { + val = PyLong_AsUnsignedLongLongMask((PyObject *)io); + Py_DECREF(io); + if (PyErr_Occurred()) + return (unsigned PY_LONG_LONG)-1; + return val; + } + else + { + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return (unsigned PY_LONG_LONG)-1; + } + } + + val = PyInt_AS_LONG(io); + Py_DECREF(io); + + return val; +} +#endif + +PyObject * +PyInt_FromString(char *s, char **pend, int base) +{ + char *end; + long x; + Py_ssize_t slen; + PyObject *sobj, *srepr; + + if ((base != 0 && base < 2) || base > 36) { + PyErr_SetString(PyExc_ValueError, + "int() base must be >= 2 and <= 36"); + return NULL; + } + + while (*s && isspace(Py_CHARMASK(*s))) + s++; + errno = 0; + if (base == 0 && s[0] == '0') { + x = (long) PyOS_strtoul(s, &end, base); + if (x < 0) + return PyLong_FromString(s, pend, base); + } + else + x = PyOS_strtol(s, &end, base); + if (end == s || !isalnum(Py_CHARMASK(end[-1]))) + goto bad; + while (*end && isspace(Py_CHARMASK(*end))) + end++; + if (*end != '\0') { + bad: + slen = strlen(s) < 200 ? strlen(s) : 200; + sobj = PyString_FromStringAndSize(s, slen); + if (sobj == NULL) + return NULL; + srepr = PyObject_Repr(sobj); + Py_DECREF(sobj); + if (srepr == NULL) + return NULL; + PyErr_Format(PyExc_ValueError, + "invalid literal for int() with base %d: %s", + base, PyString_AS_STRING(srepr)); + Py_DECREF(srepr); + return NULL; + } + else if (errno != 0) + return PyLong_FromString(s, pend, base); + if (pend) + *pend = end; + return PyInt_FromLong(x); +} + +#ifdef Py_USING_UNICODE +PyObject * +PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base) +{ + PyObject *result; + char *buffer = (char *)PyMem_MALLOC(length+1); + + if (buffer == NULL) + return PyErr_NoMemory(); + + if (PyUnicode_EncodeDecimal(s, length, buffer, NULL)) { + PyMem_FREE(buffer); + return NULL; + } + result = PyInt_FromString(buffer, NULL, base); + PyMem_FREE(buffer); + return result; +} +#endif + +/* Methods */ + +/* Integers are seen as the "smallest" of all numeric types and thus + don't have any knowledge about conversion of other types to + integers. */ + +#define CONVERT_TO_LONG(obj, lng) \ + if (PyInt_Check(obj)) { \ + lng = PyInt_AS_LONG(obj); \ + } \ + else { \ + Py_INCREF(Py_NotImplemented); \ + return Py_NotImplemented; \ + } + +/* ARGSUSED */ +static int +int_print(PyIntObject *v, FILE *fp, int flags) + /* flags -- not used but required by interface */ +{ + long int_val = v->ob_ival; + Py_BEGIN_ALLOW_THREADS + fprintf(fp, "%ld", int_val); + Py_END_ALLOW_THREADS + return 0; +} + +static PyObject * +int_repr(PyIntObject *v) +{ + return _PyInt_Format(v, 10, 0); +} + +static int +int_compare(PyIntObject *v, PyIntObject *w) +{ + register long i = v->ob_ival; + register long j = w->ob_ival; + return (i < j) ? -1 : (i > j) ? 1 : 0; +} + +static long +int_hash(PyIntObject *v) +{ + /* XXX If this is changed, you also need to change the way + Python's long, float and complex types are hashed. */ + long x = v -> ob_ival; + if (x == -1) + x = -2; + return x; +} + +static PyObject * +int_add(PyIntObject *v, PyIntObject *w) +{ + register long a, b, x; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + x = a + b; + if ((x^a) >= 0 || (x^b) >= 0) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add((PyObject *)v, (PyObject *)w); +} + +static PyObject * +int_sub(PyIntObject *v, PyIntObject *w) +{ + register long a, b, x; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + x = a - b; + if ((x^a) >= 0 || (x^~b) >= 0) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract((PyObject *)v, + (PyObject *)w); +} + +/* +Integer overflow checking for * is painful: Python tried a couple ways, but +they didn't work on all platforms, or failed in endcases (a product of +-sys.maxint-1 has been a particular pain). + +Here's another way: + +The native long product x*y is either exactly right or *way* off, being +just the last n bits of the true product, where n is the number of bits +in a long (the delivered product is the true product plus i*2**n for +some integer i). + +The native double product (double)x * (double)y is subject to three +rounding errors: on a sizeof(long)==8 box, each cast to double can lose +info, and even on a sizeof(long)==4 box, the multiplication can lose info. +But, unlike the native long product, it's not in *range* trouble: even +if sizeof(long)==32 (256-bit longs), the product easily fits in the +dynamic range of a double. So the leading 50 (or so) bits of the double +product are correct. + +We check these two ways against each other, and declare victory if they're +approximately the same. Else, because the native long product is the only +one that can lose catastrophic amounts of information, it's the native long +product that must have overflowed. +*/ + +static PyObject * +int_mul(PyObject *v, PyObject *w) +{ + long a, b; + long longprod; /* a*b in native long arithmetic */ + double doubled_longprod; /* (double)longprod */ + double doubleprod; /* (double)a * (double)b */ + + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + longprod = a * b; + doubleprod = (double)a * (double)b; + doubled_longprod = (double)longprod; + + /* Fast path for normal case: small multiplicands, and no info + is lost in either method. */ + if (doubled_longprod == doubleprod) + return PyInt_FromLong(longprod); + + /* Somebody somewhere lost info. Close enough, or way off? Note + that a != 0 and b != 0 (else doubled_longprod == doubleprod == 0). + The difference either is or isn't significant compared to the + true value (of which doubleprod is a good approximation). + */ + { + const double diff = doubled_longprod - doubleprod; + const double absdiff = diff >= 0.0 ? diff : -diff; + const double absprod = doubleprod >= 0.0 ? doubleprod : + -doubleprod; + /* absdiff/absprod <= 1/32 iff + 32 * absdiff <= absprod -- 5 good bits is "close enough" */ + if (32.0 * absdiff <= absprod) + return PyInt_FromLong(longprod); + else + return PyLong_Type.tp_as_number->nb_multiply(v, w); + } +} + +/* Integer overflow checking for unary negation: on a 2's-complement + * box, -x overflows iff x is the most negative long. In this case we + * get -x == x. However, -x is undefined (by C) if x /is/ the most + * negative long (it's a signed overflow case), and some compilers care. + * So we cast x to unsigned long first. However, then other compilers + * warn about applying unary minus to an unsigned operand. Hence the + * weird "0-". + */ +#define UNARY_NEG_WOULD_OVERFLOW(x) \ + ((x) < 0 && (unsigned long)(x) == 0-(unsigned long)(x)) + +/* Return type of i_divmod */ +enum divmod_result { + DIVMOD_OK, /* Correct result */ + DIVMOD_OVERFLOW, /* Overflow, try again using longs */ + DIVMOD_ERROR /* Exception raised */ +}; + +static enum divmod_result +i_divmod(register long x, register long y, + long *p_xdivy, long *p_xmody) +{ + long xdivy, xmody; + + if (y == 0) { + PyErr_SetString(PyExc_ZeroDivisionError, + "integer division or modulo by zero"); + return DIVMOD_ERROR; + } + /* (-sys.maxint-1)/-1 is the only overflow case. */ + if (y == -1 && UNARY_NEG_WOULD_OVERFLOW(x)) + return DIVMOD_OVERFLOW; + xdivy = x / y; + xmody = x - xdivy * y; + /* If the signs of x and y differ, and the remainder is non-0, + * C89 doesn't define whether xdivy is now the floor or the + * ceiling of the infinitely precise quotient. We want the floor, + * and we have it iff the remainder's sign matches y's. + */ + if (xmody && ((y ^ xmody) < 0) /* i.e. and signs differ */) { + xmody += y; + --xdivy; + assert(xmody && ((y ^ xmody) >= 0)); + } + *p_xdivy = xdivy; + *p_xmody = xmody; + return DIVMOD_OK; +} + +static PyObject * +int_div(PyIntObject *x, PyIntObject *y) +{ + long xi, yi; + long d, m; + CONVERT_TO_LONG(x, xi); + CONVERT_TO_LONG(y, yi); + switch (i_divmod(xi, yi, &d, &m)) { + case DIVMOD_OK: + return PyInt_FromLong(d); + case DIVMOD_OVERFLOW: + return PyLong_Type.tp_as_number->nb_divide((PyObject *)x, + (PyObject *)y); + default: + return NULL; + } +} + +static PyObject * +int_classic_div(PyIntObject *x, PyIntObject *y) +{ + long xi, yi; + long d, m; + CONVERT_TO_LONG(x, xi); + CONVERT_TO_LONG(y, yi); + if (Py_DivisionWarningFlag && + PyErr_Warn(PyExc_DeprecationWarning, "classic int division") < 0) + return NULL; + switch (i_divmod(xi, yi, &d, &m)) { + case DIVMOD_OK: + return PyInt_FromLong(d); + case DIVMOD_OVERFLOW: + return PyLong_Type.tp_as_number->nb_divide((PyObject *)x, + (PyObject *)y); + default: + return NULL; + } +} + +static PyObject * +int_true_divide(PyObject *v, PyObject *w) +{ + /* If they aren't both ints, give someone else a chance. In + particular, this lets int/long get handled by longs, which + underflows to 0 gracefully if the long is too big to convert + to float. */ + if (PyInt_Check(v) && PyInt_Check(w)) + return PyFloat_Type.tp_as_number->nb_true_divide(v, w); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + +static PyObject * +int_mod(PyIntObject *x, PyIntObject *y) +{ + long xi, yi; + long d, m; + CONVERT_TO_LONG(x, xi); + CONVERT_TO_LONG(y, yi); + switch (i_divmod(xi, yi, &d, &m)) { + case DIVMOD_OK: + return PyInt_FromLong(m); + case DIVMOD_OVERFLOW: + return PyLong_Type.tp_as_number->nb_remainder((PyObject *)x, + (PyObject *)y); + default: + return NULL; + } +} + +static PyObject * +int_divmod(PyIntObject *x, PyIntObject *y) +{ + long xi, yi; + long d, m; + CONVERT_TO_LONG(x, xi); + CONVERT_TO_LONG(y, yi); + switch (i_divmod(xi, yi, &d, &m)) { + case DIVMOD_OK: + return Py_BuildValue("(ll)", d, m); + case DIVMOD_OVERFLOW: + return PyLong_Type.tp_as_number->nb_divmod((PyObject *)x, + (PyObject *)y); + default: + return NULL; + } +} + +static PyObject * +int_pow(PyIntObject *v, PyIntObject *w, PyIntObject *z) +{ + register long iv, iw, iz=0, ix, temp, prev; + CONVERT_TO_LONG(v, iv); + CONVERT_TO_LONG(w, iw); + if (iw < 0) { + if ((PyObject *)z != Py_None) { + PyErr_SetString(PyExc_TypeError, "pow() 2nd argument " + "cannot be negative when 3rd argument specified"); + return NULL; + } + /* Return a float. This works because we know that + this calls float_pow() which converts its + arguments to double. */ + return PyFloat_Type.tp_as_number->nb_power( + (PyObject *)v, (PyObject *)w, (PyObject *)z); + } + if ((PyObject *)z != Py_None) { + CONVERT_TO_LONG(z, iz); + if (iz == 0) { + PyErr_SetString(PyExc_ValueError, + "pow() 3rd argument cannot be 0"); + return NULL; + } + } + /* + * XXX: The original exponentiation code stopped looping + * when temp hit zero; this code will continue onwards + * unnecessarily, but at least it won't cause any errors. + * Hopefully the speed improvement from the fast exponentiation + * will compensate for the slight inefficiency. + * XXX: Better handling of overflows is desperately needed. + */ + temp = iv; + ix = 1; + while (iw > 0) { + prev = ix; /* Save value for overflow check */ + if (iw & 1) { + ix = ix*temp; + if (temp == 0) + break; /* Avoid ix / 0 */ + if (ix / temp != prev) { + return PyLong_Type.tp_as_number->nb_power( + (PyObject *)v, + (PyObject *)w, + (PyObject *)z); + } + } + iw >>= 1; /* Shift exponent down by 1 bit */ + if (iw==0) break; + prev = temp; + temp *= temp; /* Square the value of temp */ + if (prev != 0 && temp / prev != prev) { + return PyLong_Type.tp_as_number->nb_power( + (PyObject *)v, (PyObject *)w, (PyObject *)z); + } + if (iz) { + /* If we did a multiplication, perform a modulo */ + ix = ix % iz; + temp = temp % iz; + } + } + if (iz) { + long div, mod; + switch (i_divmod(ix, iz, &div, &mod)) { + case DIVMOD_OK: + ix = mod; + break; + case DIVMOD_OVERFLOW: + return PyLong_Type.tp_as_number->nb_power( + (PyObject *)v, (PyObject *)w, (PyObject *)z); + default: + return NULL; + } + } + return PyInt_FromLong(ix); +} + +static PyObject * +int_neg(PyIntObject *v) +{ + register long a; + a = v->ob_ival; + /* check for overflow */ + if (UNARY_NEG_WOULD_OVERFLOW(a)) { + PyObject *o = PyLong_FromLong(a); + if (o != NULL) { + PyObject *result = PyNumber_Negative(o); + Py_DECREF(o); + return result; + } + return NULL; + } + return PyInt_FromLong(-a); +} + +static PyObject * +int_abs(PyIntObject *v) +{ + if (v->ob_ival >= 0) + return int_int(v); + else + return int_neg(v); +} + +static int +int_nonzero(PyIntObject *v) +{ + return v->ob_ival != 0; +} + +static PyObject * +int_invert(PyIntObject *v) +{ + return PyInt_FromLong(~v->ob_ival); +} + +static PyObject * +int_lshift(PyIntObject *v, PyIntObject *w) +{ + long a, b, c; + PyObject *vv, *ww, *result; + + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + if (b < 0) { + PyErr_SetString(PyExc_ValueError, "negative shift count"); + return NULL; + } + if (a == 0 || b == 0) + return int_int(v); + if (b >= LONG_BIT) { + vv = PyLong_FromLong(PyInt_AS_LONG(v)); + if (vv == NULL) + return NULL; + ww = PyLong_FromLong(PyInt_AS_LONG(w)); + if (ww == NULL) { + Py_DECREF(vv); + return NULL; + } + result = PyNumber_Lshift(vv, ww); + Py_DECREF(vv); + Py_DECREF(ww); + return result; + } + c = a << b; + if (a != Py_ARITHMETIC_RIGHT_SHIFT(long, c, b)) { + vv = PyLong_FromLong(PyInt_AS_LONG(v)); + if (vv == NULL) + return NULL; + ww = PyLong_FromLong(PyInt_AS_LONG(w)); + if (ww == NULL) { + Py_DECREF(vv); + return NULL; + } + result = PyNumber_Lshift(vv, ww); + Py_DECREF(vv); + Py_DECREF(ww); + return result; + } + return PyInt_FromLong(c); +} + +static PyObject * +int_rshift(PyIntObject *v, PyIntObject *w) +{ + register long a, b; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + if (b < 0) { + PyErr_SetString(PyExc_ValueError, "negative shift count"); + return NULL; + } + if (a == 0 || b == 0) + return int_int(v); + if (b >= LONG_BIT) { + if (a < 0) + a = -1; + else + a = 0; + } + else { + a = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b); + } + return PyInt_FromLong(a); +} + +static PyObject * +int_and(PyIntObject *v, PyIntObject *w) +{ + register long a, b; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + return PyInt_FromLong(a & b); +} + +static PyObject * +int_xor(PyIntObject *v, PyIntObject *w) +{ + register long a, b; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + return PyInt_FromLong(a ^ b); +} + +static PyObject * +int_or(PyIntObject *v, PyIntObject *w) +{ + register long a, b; + CONVERT_TO_LONG(v, a); + CONVERT_TO_LONG(w, b); + return PyInt_FromLong(a | b); +} + +static int +int_coerce(PyObject **pv, PyObject **pw) +{ + if (PyInt_Check(*pw)) { + Py_INCREF(*pv); + Py_INCREF(*pw); + return 0; + } + return 1; /* Can't do it */ +} + +static PyObject * +int_int(PyIntObject *v) +{ + if (PyInt_CheckExact(v)) + Py_INCREF(v); + else + v = (PyIntObject *)PyInt_FromLong(v->ob_ival); + return (PyObject *)v; +} + +static PyObject * +int_long(PyIntObject *v) +{ + return PyLong_FromLong((v -> ob_ival)); +} + +static PyObject * +int_float(PyIntObject *v) +{ + return PyFloat_FromDouble((double)(v -> ob_ival)); +} + +static PyObject * +int_oct(PyIntObject *v) +{ + return _PyInt_Format(v, 8, 0); +} + +static PyObject * +int_hex(PyIntObject *v) +{ + return _PyInt_Format(v, 16, 0); +} + +static PyObject * +int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); + +static PyObject * +int_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *x = NULL; + int base = -909; + static char *kwlist[] = {"x", "base", 0}; + + if (type != &PyInt_Type) + return int_subtype_new(type, args, kwds); /* Wimp out */ + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:int", kwlist, + &x, &base)) + return NULL; + if (x == NULL) + return PyInt_FromLong(0L); + if (base == -909) + return PyNumber_Int(x); + if (PyString_Check(x)) { + /* Since PyInt_FromString doesn't have a length parameter, + * check here for possible NULs in the string. */ + char *string = PyString_AS_STRING(x); + if (strlen(string) != PyString_Size(x)) { + /* create a repr() of the input string, + * just like PyInt_FromString does */ + PyObject *srepr; + srepr = PyObject_Repr(x); + if (srepr == NULL) + return NULL; + PyErr_Format(PyExc_ValueError, + "invalid literal for int() with base %d: %s", + base, PyString_AS_STRING(srepr)); + Py_DECREF(srepr); + return NULL; + } + return PyInt_FromString(string, NULL, base); + } +#ifdef Py_USING_UNICODE + if (PyUnicode_Check(x)) + return PyInt_FromUnicode(PyUnicode_AS_UNICODE(x), + PyUnicode_GET_SIZE(x), + base); +#endif + PyErr_SetString(PyExc_TypeError, + "int() can't convert non-string with explicit base"); + return NULL; +} + +/* Wimpy, slow approach to tp_new calls for subtypes of int: + first create a regular int from whatever arguments we got, + then allocate a subtype instance and initialize its ob_ival + from the regular int. The regular int is then thrown away. +*/ +static PyObject * +int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *tmp, *newobj; + long ival; + + assert(PyType_IsSubtype(type, &PyInt_Type)); + tmp = int_new(&PyInt_Type, args, kwds); + if (tmp == NULL) + return NULL; + if (!PyInt_Check(tmp)) { + ival = PyLong_AsLong(tmp); + if (ival == -1 && PyErr_Occurred()) { + Py_DECREF(tmp); + return NULL; + } + } else { + ival = ((PyIntObject *)tmp)->ob_ival; + } + + newobj = type->tp_alloc(type, 0); + if (newobj == NULL) { + Py_DECREF(tmp); + return NULL; + } + ((PyIntObject *)newobj)->ob_ival = ival; + Py_DECREF(tmp); + return newobj; +} + +static PyObject * +int_getnewargs(PyIntObject *v) +{ + return Py_BuildValue("(l)", v->ob_ival); +} + +static PyObject * +int_getN(PyIntObject *v, void *context) { + return PyInt_FromLong((Py_intptr_t)context); +} + +/* Convert an integer to the given base. Returns a string. + If base is 2, 8 or 16, add the proper prefix '0b', '0o' or '0x'. + If newstyle is zero, then use the pre-2.6 behavior of octal having + a leading "0" */ +PyAPI_FUNC(PyObject*) +_PyInt_Format(PyIntObject *v, int base, int newstyle) +{ + /* There are no doubt many, many ways to optimize this, using code + similar to _PyLong_Format */ + long n = v->ob_ival; + int negative = n < 0; + int is_zero = n == 0; + + /* For the reasoning behind this size, see + http://c-faq.com/misc/hexio.html. Then, add a few bytes for + the possible sign and prefix "0[box]" */ + char buf[sizeof(n)*CHAR_BIT+6]; + + /* Start by pointing to the end of the buffer. We fill in from + the back forward. */ + char* p = &buf[sizeof(buf)]; + + assert(base >= 2 && base <= 36); + + do { + /* I'd use i_divmod, except it doesn't produce the results + I want when n is negative. So just duplicate the salient + part here. */ + long div = n / base; + long mod = n - div * base; + + /* convert abs(mod) to the right character in [0-9, a-z] */ + char cdigit = (char)(mod < 0 ? -mod : mod); + cdigit += (cdigit < 10) ? '0' : 'a'-10; + *--p = cdigit; + + n = div; + } while(n); + + if (base == 2) { + *--p = 'b'; + *--p = '0'; + } + else if (base == 8) { + if (newstyle) { + *--p = 'o'; + *--p = '0'; + } + else + if (!is_zero) + *--p = '0'; + } + else if (base == 16) { + *--p = 'x'; + *--p = '0'; + } + else if (base != 10) { + *--p = '#'; + *--p = '0' + base%10; + if (base > 10) + *--p = '0' + base/10; + } + if (negative) + *--p = '-'; + + return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p); +} + +static PyObject * +int__format__(PyObject *self, PyObject *args) +{ + PyObject *format_spec; + + if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) + return NULL; + if (PyBytes_Check(format_spec)) + return _PyInt_FormatAdvanced(self, + PyBytes_AS_STRING(format_spec), + PyBytes_GET_SIZE(format_spec)); + if (PyUnicode_Check(format_spec)) { + /* Convert format_spec to a str */ + PyObject *result; + PyObject *str_spec = PyObject_Str(format_spec); + + if (str_spec == NULL) + return NULL; + + result = _PyInt_FormatAdvanced(self, + PyBytes_AS_STRING(str_spec), + PyBytes_GET_SIZE(str_spec)); + + Py_DECREF(str_spec); + return result; + } + PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); + return NULL; +} + +#if 0 +static PyObject * +int_is_finite(PyObject *v) +{ + Py_RETURN_TRUE; +} +#endif + +static PyMethodDef int_methods[] = { + {"conjugate", (PyCFunction)int_int, METH_NOARGS, + "Returns self, the complex conjugate of any int."}, +#if 0 + {"is_finite", (PyCFunction)int_is_finite, METH_NOARGS, + "Returns always True."}, +#endif + {"__trunc__", (PyCFunction)int_int, METH_NOARGS, + "Truncating an Integral returns itself."}, + {"__getnewargs__", (PyCFunction)int_getnewargs, METH_NOARGS}, + {"__format__", (PyCFunction)int__format__, METH_VARARGS}, + {NULL, NULL} /* sentinel */ +}; + +static PyGetSetDef int_getset[] = { + {"real", + (getter)int_int, (setter)NULL, + "the real part of a complex number", + NULL}, + {"imag", + (getter)int_getN, (setter)NULL, + "the imaginary part of a complex number", + (void*)0}, + {"numerator", + (getter)int_int, (setter)NULL, + "the numerator of a rational number in lowest terms", + NULL}, + {"denominator", + (getter)int_getN, (setter)NULL, + "the denominator of a rational number in lowest terms", + (void*)1}, + {NULL} /* Sentinel */ +}; + +PyDoc_STRVAR(int_doc, +"int(x[, base]) -> integer\n\ +\n\ +Convert a string or number to an integer, if possible. A floating point\n\ +argument will be truncated towards zero (this does not include a string\n\ +representation of a floating point number!) When converting a string, use\n\ +the optional base. It is an error to supply a base when converting a\n\ +non-string. If base is zero, the proper base is guessed based on the\n\ +string content. If the argument is outside the integer range a\n\ +long object will be returned instead."); + +static PyNumberMethods int_as_number = { + (binaryfunc)int_add, /*nb_add*/ + (binaryfunc)int_sub, /*nb_subtract*/ + (binaryfunc)int_mul, /*nb_multiply*/ + (binaryfunc)int_classic_div, /*nb_divide*/ + (binaryfunc)int_mod, /*nb_remainder*/ + (binaryfunc)int_divmod, /*nb_divmod*/ + (ternaryfunc)int_pow, /*nb_power*/ + (unaryfunc)int_neg, /*nb_negative*/ + (unaryfunc)int_int, /*nb_positive*/ + (unaryfunc)int_abs, /*nb_absolute*/ + (inquiry)int_nonzero, /*nb_nonzero*/ + (unaryfunc)int_invert, /*nb_invert*/ + (binaryfunc)int_lshift, /*nb_lshift*/ + (binaryfunc)int_rshift, /*nb_rshift*/ + (binaryfunc)int_and, /*nb_and*/ + (binaryfunc)int_xor, /*nb_xor*/ + (binaryfunc)int_or, /*nb_or*/ + int_coerce, /*nb_coerce*/ + (unaryfunc)int_int, /*nb_int*/ + (unaryfunc)int_long, /*nb_long*/ + (unaryfunc)int_float, /*nb_float*/ + (unaryfunc)int_oct, /*nb_oct*/ + (unaryfunc)int_hex, /*nb_hex*/ + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + 0, /*nb_inplace_divide*/ + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + (binaryfunc)int_div, /* nb_floor_divide */ + int_true_divide, /* nb_true_divide */ + 0, /* nb_inplace_floor_divide */ + 0, /* nb_inplace_true_divide */ + (unaryfunc)int_int, /* nb_index */ +}; + +PyTypeObject PyInt_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "int", + sizeof(PyIntObject), + 0, + (destructor)int_dealloc, /* tp_dealloc */ + (printfunc)int_print, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + (cmpfunc)int_compare, /* tp_compare */ + (reprfunc)int_repr, /* tp_repr */ + &int_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)int_hash, /* tp_hash */ + 0, /* tp_call */ + (reprfunc)int_repr, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | + Py_TPFLAGS_BASETYPE | Py_TPFLAGS_INT_SUBCLASS, /* tp_flags */ + int_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + int_methods, /* tp_methods */ + 0, /* tp_members */ + int_getset, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + int_new, /* tp_new */ + (freefunc)int_free, /* tp_free */ +}; + +int +_PyInt_Init(void) +{ + PyIntObject *v; + int ival; +#if NSMALLNEGINTS + NSMALLPOSINTS > 0 + for (ival = -NSMALLNEGINTS; ival < NSMALLPOSINTS; ival++) { + if (!free_list && (free_list = fill_free_list()) == NULL) + return 0; + /* PyObject_New is inlined */ + v = free_list; + free_list = (PyIntObject *)Py_TYPE(v); + PyObject_INIT(v, &PyInt_Type); + v->ob_ival = ival; + small_ints[ival + NSMALLNEGINTS] = v; + } +#endif + return 1; +} + +int +PyInt_ClearFreeList(void) +{ + PyIntObject *p; + PyIntBlock *list, *next; + int i; + int u; /* remaining unfreed ints per block */ + int freelist_size = 0; + + list = block_list; + block_list = NULL; + free_list = NULL; + while (list != NULL) { + u = 0; + for (i = 0, p = &list->objects[0]; + i < N_INTOBJECTS; + i++, p++) { + if (PyInt_CheckExact(p) && p->ob_refcnt != 0) + u++; + } + next = list->next; + if (u) { + list->next = block_list; + block_list = list; + for (i = 0, p = &list->objects[0]; + i < N_INTOBJECTS; + i++, p++) { + if (!PyInt_CheckExact(p) || + p->ob_refcnt == 0) { + Py_TYPE(p) = (struct _typeobject *) + free_list; + free_list = p; + } +#if NSMALLNEGINTS + NSMALLPOSINTS > 0 + else if (-NSMALLNEGINTS <= p->ob_ival && + p->ob_ival < NSMALLPOSINTS && + small_ints[p->ob_ival + + NSMALLNEGINTS] == NULL) { + Py_INCREF(p); + small_ints[p->ob_ival + + NSMALLNEGINTS] = p; + } +#endif + } + } + else { + PyMem_FREE(list); + } + freelist_size += u; + list = next; + } + + return freelist_size; +} + +void +PyInt_Fini(void) +{ + PyIntObject *p; + PyIntBlock *list; + int i; + int u; /* total unfreed ints per block */ + +#if NSMALLNEGINTS + NSMALLPOSINTS > 0 + PyIntObject **q; + + i = NSMALLNEGINTS + NSMALLPOSINTS; + q = small_ints; + while (--i >= 0) { + Py_XDECREF(*q); + *q++ = NULL; + } +#endif + u = PyInt_ClearFreeList(); + if (!Py_VerboseFlag) + return; + fprintf(stderr, "# cleanup ints"); + if (!u) { + fprintf(stderr, "\n"); + } + else { + fprintf(stderr, + ": %d unfreed int%s\n", + u, u == 1 ? "" : "s"); + } + if (Py_VerboseFlag > 1) { + list = block_list; + while (list != NULL) { + for (i = 0, p = &list->objects[0]; + i < N_INTOBJECTS; + i++, p++) { + if (PyInt_CheckExact(p) && p->ob_refcnt != 0) + /* XXX(twouters) cast refcount to + long until %zd is universally + available + */ + fprintf(stderr, + "# \n", + p, (long)p->ob_refcnt, + p->ob_ival); + } + list = list->next; + } + } +}