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