Untabify C files. Will watch buildbots.
diff --git a/Objects/intobject.c b/Objects/intobject.c
index b302d2f..7d70bfb 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -10,7 +10,7 @@
long
PyInt_GetMax(void)
{
- return LONG_MAX; /* To initialize sys.maxint */
+ return LONG_MAX; /* To initialize sys.maxint */
}
/* Integers are quite normal objects, to make object handling uniform.
@@ -30,13 +30,13 @@
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))
+#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];
+ struct _intblock *next;
+ PyIntObject objects[N_INTOBJECTS];
};
typedef struct _intblock PyIntBlock;
@@ -47,28 +47,28 @@
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;
+ 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
+#define NSMALLPOSINTS 257
#endif
#ifndef NSMALLNEGINTS
-#define NSMALLNEGINTS 5
+#define NSMALLNEGINTS 5
#endif
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
/* References to small integers are saved in this array so that they
@@ -86,326 +86,326 @@
PyObject *
PyInt_FromLong(long ival)
{
- register PyIntObject *v;
+ register PyIntObject *v;
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
- if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
- v = small_ints[ival + NSMALLNEGINTS];
- Py_INCREF(v);
+ 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++;
+ if (ival >= 0)
+ quick_int_allocs++;
+ else
+ quick_neg_int_allocs++;
#endif
- return (PyObject *) v;
- }
+ 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;
+ 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);
+ 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);
+ 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);
+ 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;
+ Py_TYPE(v) = (struct _typeobject *)free_list;
+ free_list = v;
}
long
PyInt_AsLong(register PyObject *op)
{
- PyNumberMethods *nb;
- PyIntObject *io;
- long val;
+ PyNumberMethods *nb;
+ PyIntObject *io;
+ long val;
- if (op && PyInt_Check(op))
- return PyInt_AS_LONG((PyIntObject*) op);
+ 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;
- }
+ 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,
- "__int__ method should return an integer");
- 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,
+ "__int__ method should return an integer");
+ return -1;
+ }
+ }
- val = PyInt_AS_LONG(io);
- Py_DECREF(io);
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
- return val;
+ 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;
+ PyNumberMethods *nb;
+ PyIntObject *io;
+ Py_ssize_t val;
#endif
- if (op == NULL) {
- PyErr_SetString(PyExc_TypeError, "an integer is required");
- return -1;
- }
+ 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 (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);
+ 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 = 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,
- "__int__ method should return an integer");
- 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,
+ "__int__ method should return an integer");
+ return -1;
+ }
+ }
- val = PyInt_AS_LONG(io);
- Py_DECREF(io);
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
- return val;
+ return val;
#endif
}
unsigned long
PyInt_AsUnsignedLongMask(register PyObject *op)
{
- PyNumberMethods *nb;
- PyIntObject *io;
- unsigned long val;
+ 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 && 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;
- }
+ 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,
- "__int__ method should return an integer");
- 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,
+ "__int__ method should return an integer");
+ return (unsigned long)-1;
+ }
+ }
- val = PyInt_AS_LONG(io);
- Py_DECREF(io);
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
- return val;
+ return val;
}
#ifdef HAVE_LONG_LONG
unsigned PY_LONG_LONG
PyInt_AsUnsignedLongLongMask(register PyObject *op)
{
- PyNumberMethods *nb;
- PyIntObject *io;
- unsigned PY_LONG_LONG val;
+ 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 && 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;
- }
+ 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,
- "__int__ method should return an integer");
- 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,
+ "__int__ method should return an integer");
+ return (unsigned PY_LONG_LONG)-1;
+ }
+ }
- val = PyInt_AS_LONG(io);
- Py_DECREF(io);
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
- return val;
+ return val;
}
#endif
PyObject *
PyInt_FromString(char *s, char **pend, int base)
{
- char *end;
- long x;
- Py_ssize_t slen;
- PyObject *sobj, *srepr;
+ 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;
- }
+ 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') {
+ 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);
+ 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);
+ PyObject *result;
+ char *buffer = (char *)PyMem_MALLOC(length+1);
- if (buffer == NULL)
- return PyErr_NoMemory();
+ 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;
+ if (PyUnicode_EncodeDecimal(s, length, buffer, NULL)) {
+ PyMem_FREE(buffer);
+ return NULL;
+ }
+ result = PyInt_FromString(buffer, NULL, base);
+ PyMem_FREE(buffer);
+ return result;
}
#endif
@@ -415,71 +415,71 @@
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; \
- }
+#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;
+ long int_val = v->ob_ival;
+ Py_BEGIN_ALLOW_THREADS
+ fprintf(fp, "%ld", int_val);
+ Py_END_ALLOW_THREADS
+ return 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;
+ 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;
+ /* 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);
- /* casts in the line below avoid undefined behaviour on overflow */
- x = (long)((unsigned long)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);
+ register long a, b, x;
+ CONVERT_TO_LONG(v, a);
+ CONVERT_TO_LONG(w, b);
+ /* casts in the line below avoid undefined behaviour on overflow */
+ x = (long)((unsigned long)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);
- /* casts in the line below avoid undefined behaviour on overflow */
- x = (long)((unsigned long)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);
+ register long a, b, x;
+ CONVERT_TO_LONG(v, a);
+ CONVERT_TO_LONG(w, b);
+ /* casts in the line below avoid undefined behaviour on overflow */
+ x = (long)((unsigned long)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);
}
/*
@@ -511,40 +511,40 @@
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 */
+ 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);
- /* casts in the next line avoid undefined behaviour on overflow */
- longprod = (long)((unsigned long)a * b);
- doubleprod = (double)a * (double)b;
- doubled_longprod = (double)longprod;
+ CONVERT_TO_LONG(v, a);
+ CONVERT_TO_LONG(w, b);
+ /* casts in the next line avoid undefined behaviour on overflow */
+ longprod = (long)((unsigned long)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);
+ /* 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);
- }
+ /* 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
@@ -555,420 +555,420 @@
* 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))
+#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 */
+ 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;
+ 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;
- /* xdiv*y can overflow on platforms where x/y gives floor(x/y)
- * for x and y with differing signs. (This is unusual
- * behaviour, and C99 prohibits it, but it's allowed by C89;
- * for an example of overflow, take x = LONG_MIN, y = 5 or x =
- * LONG_MAX, y = -5.) However, x - xdivy*y is always
- * representable as a long, since it lies strictly between
- * -abs(y) and abs(y). We add casts to avoid intermediate
- * overflow.
- */
- xmody = (long)(x - (unsigned long)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;
+ 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;
+ /* xdiv*y can overflow on platforms where x/y gives floor(x/y)
+ * for x and y with differing signs. (This is unusual
+ * behaviour, and C99 prohibits it, but it's allowed by C89;
+ * for an example of overflow, take x = LONG_MIN, y = 5 or x =
+ * LONG_MAX, y = -5.) However, x - xdivy*y is always
+ * representable as a long, since it lies strictly between
+ * -abs(y) and abs(y). We add casts to avoid intermediate
+ * overflow.
+ */
+ xmody = (long)(x - (unsigned long)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;
- }
+ 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;
- }
+ 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(PyIntObject *x, PyIntObject *y)
{
- long xi, yi;
- /* 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. */
- CONVERT_TO_LONG(x, xi);
- CONVERT_TO_LONG(y, yi);
- if (yi == 0) {
- PyErr_SetString(PyExc_ZeroDivisionError,
- "division by zero");
- return NULL;
- }
- if (xi == 0)
- return PyFloat_FromDouble(yi < 0 ? -0.0 : 0.0);
+ long xi, yi;
+ /* 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. */
+ CONVERT_TO_LONG(x, xi);
+ CONVERT_TO_LONG(y, yi);
+ if (yi == 0) {
+ PyErr_SetString(PyExc_ZeroDivisionError,
+ "division by zero");
+ return NULL;
+ }
+ if (xi == 0)
+ return PyFloat_FromDouble(yi < 0 ? -0.0 : 0.0);
#define WIDTH_OF_ULONG (CHAR_BIT*SIZEOF_LONG)
#if DBL_MANT_DIG < WIDTH_OF_ULONG
- if ((xi >= 0 ? 0UL + xi : 0UL - xi) >> DBL_MANT_DIG ||
- (yi >= 0 ? 0UL + yi : 0UL - yi) >> DBL_MANT_DIG)
- /* Large x or y. Use long integer arithmetic. */
- return PyLong_Type.tp_as_number->nb_true_divide(
- (PyObject *)x, (PyObject *)y);
- else
+ if ((xi >= 0 ? 0UL + xi : 0UL - xi) >> DBL_MANT_DIG ||
+ (yi >= 0 ? 0UL + yi : 0UL - yi) >> DBL_MANT_DIG)
+ /* Large x or y. Use long integer arithmetic. */
+ return PyLong_Type.tp_as_number->nb_true_divide(
+ (PyObject *)x, (PyObject *)y);
+ else
#endif
- /* Both ints can be exactly represented as doubles. Do a
- floating-point division. */
- return PyFloat_FromDouble((double)xi / (double)yi);
+ /* Both ints can be exactly represented as doubles. Do a
+ floating-point division. */
+ return PyFloat_FromDouble((double)xi / (double)yi);
}
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;
- }
+ 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;
- }
+ 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);
+ 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);
+ 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);
+ 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;
+ return v->ob_ival != 0;
}
static PyObject *
int_invert(PyIntObject *v)
{
- return PyInt_FromLong(~v->ob_ival);
+ return PyInt_FromLong(~v->ob_ival);
}
static PyObject *
int_lshift(PyIntObject *v, PyIntObject *w)
{
- long a, b, c;
- PyObject *vv, *ww, *result;
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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 */
+ 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;
+ 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));
+ return PyLong_FromLong((v -> ob_ival));
}
static const unsigned char BitLengthTable[32] = {
- 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
+ 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
};
static int
bits_in_ulong(unsigned long d)
{
- int d_bits = 0;
- while (d >= 32) {
- d_bits += 6;
- d >>= 6;
- }
- d_bits += (int)BitLengthTable[d];
- return d_bits;
+ int d_bits = 0;
+ while (d >= 32) {
+ d_bits += 6;
+ d >>= 6;
+ }
+ d_bits += (int)BitLengthTable[d];
+ return d_bits;
}
#if 8*SIZEOF_LONG-1 <= DBL_MANT_DIG
@@ -977,7 +977,7 @@
static PyObject *
int_float(PyIntObject *v)
{
- return PyFloat_FromDouble((double)(v -> ob_ival));
+ return PyFloat_FromDouble((double)(v -> ob_ival));
}
#else
@@ -988,40 +988,40 @@
static PyObject *
int_float(PyIntObject *v)
{
- unsigned long abs_ival, lsb;
- int round_up;
+ unsigned long abs_ival, lsb;
+ int round_up;
- if (v->ob_ival < 0)
- abs_ival = 0U-(unsigned long)v->ob_ival;
- else
- abs_ival = (unsigned long)v->ob_ival;
- if (abs_ival < (1L << DBL_MANT_DIG))
- /* small integer; no need to round */
- return PyFloat_FromDouble((double)v->ob_ival);
+ if (v->ob_ival < 0)
+ abs_ival = 0U-(unsigned long)v->ob_ival;
+ else
+ abs_ival = (unsigned long)v->ob_ival;
+ if (abs_ival < (1L << DBL_MANT_DIG))
+ /* small integer; no need to round */
+ return PyFloat_FromDouble((double)v->ob_ival);
- /* Round abs_ival to MANT_DIG significant bits, using the
- round-half-to-even rule. abs_ival & lsb picks out the 'rounding'
- bit: the first bit after the most significant MANT_DIG bits of
- abs_ival. We round up if this bit is set, provided that either:
+ /* Round abs_ival to MANT_DIG significant bits, using the
+ round-half-to-even rule. abs_ival & lsb picks out the 'rounding'
+ bit: the first bit after the most significant MANT_DIG bits of
+ abs_ival. We round up if this bit is set, provided that either:
- (1) abs_ival isn't exactly halfway between two floats, in which
- case at least one of the bits following the rounding bit must be
- set; i.e., abs_ival & lsb-1 != 0, or:
+ (1) abs_ival isn't exactly halfway between two floats, in which
+ case at least one of the bits following the rounding bit must be
+ set; i.e., abs_ival & lsb-1 != 0, or:
- (2) the resulting rounded value has least significant bit 0; or
- in other words the bit above the rounding bit is set (this is the
- 'to-even' bit of round-half-to-even); i.e., abs_ival & 2*lsb != 0
+ (2) the resulting rounded value has least significant bit 0; or
+ in other words the bit above the rounding bit is set (this is the
+ 'to-even' bit of round-half-to-even); i.e., abs_ival & 2*lsb != 0
- The condition "(1) or (2)" equates to abs_ival & 3*lsb-1 != 0. */
+ The condition "(1) or (2)" equates to abs_ival & 3*lsb-1 != 0. */
- lsb = 1L << (bits_in_ulong(abs_ival)-DBL_MANT_DIG-1);
- round_up = (abs_ival & lsb) && (abs_ival & (3*lsb-1));
- abs_ival &= -2*lsb;
- if (round_up)
- abs_ival += 2*lsb;
- return PyFloat_FromDouble(v->ob_ival < 0 ?
- -(double)abs_ival :
- (double)abs_ival);
+ lsb = 1L << (bits_in_ulong(abs_ival)-DBL_MANT_DIG-1);
+ round_up = (abs_ival & lsb) && (abs_ival & (3*lsb-1));
+ abs_ival &= -2*lsb;
+ if (round_up)
+ abs_ival += 2*lsb;
+ return PyFloat_FromDouble(v->ob_ival < 0 ?
+ -(double)abs_ival :
+ (double)abs_ival);
}
#endif
@@ -1029,13 +1029,13 @@
static PyObject *
int_oct(PyIntObject *v)
{
- return _PyInt_Format(v, 8, 0);
+ return _PyInt_Format(v, 8, 0);
}
static PyObject *
int_hex(PyIntObject *v)
{
- return _PyInt_Format(v, 16, 0);
+ return _PyInt_Format(v, 16, 0);
}
static PyObject *
@@ -1044,47 +1044,47 @@
static PyObject *
int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *x = NULL;
- int base = -909;
- static char *kwlist[] = {"x", "base", 0};
+ 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);
- }
+ 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);
+ 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;
+ 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:
@@ -1095,47 +1095,47 @@
static PyObject *
int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *tmp, *newobj;
- long ival;
+ 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;
- }
+ 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;
+ 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);
+ return Py_BuildValue("(l)", v->ob_ival);
}
static PyObject *
int_get0(PyIntObject *v, void *context) {
- return PyInt_FromLong(0L);
+ return PyInt_FromLong(0L);
}
static PyObject *
int_get1(PyIntObject *v, void *context) {
- return PyInt_FromLong(1L);
+ return PyInt_FromLong(1L);
}
/* Convert an integer to a decimal string. On many platforms, this
@@ -1144,18 +1144,18 @@
opportunities offered by division by a compile-time constant. */
static PyObject *
int_to_decimal_string(PyIntObject *v) {
- char buf[sizeof(long)*CHAR_BIT/3+6], *p, *bufend;
- long n = v->ob_ival;
- unsigned long absn;
- p = bufend = buf + sizeof(buf);
- absn = n < 0 ? 0UL - n : n;
- do {
- *--p = '0' + (char)(absn % 10);
- absn /= 10;
- } while (absn);
- if (n < 0)
- *--p = '-';
- return PyString_FromStringAndSize(p, bufend - p);
+ char buf[sizeof(long)*CHAR_BIT/3+6], *p, *bufend;
+ long n = v->ob_ival;
+ unsigned long absn;
+ p = bufend = buf + sizeof(buf);
+ absn = n < 0 ? 0UL - n : n;
+ do {
+ *--p = '0' + (char)(absn % 10);
+ absn /= 10;
+ } while (absn);
+ if (n < 0)
+ *--p = '-';
+ return PyString_FromStringAndSize(p, bufend - p);
}
/* Convert an integer to the given base. Returns a string.
@@ -1165,113 +1165,113 @@
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;
+ /* 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];
+ /* 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)];
+ /* 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);
+ assert(base >= 2 && base <= 36);
- /* Special case base 10, for speed */
- if (base == 10)
- return int_to_decimal_string(v);
+ /* Special case base 10, for speed */
+ if (base == 10)
+ return int_to_decimal_string(v);
- 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;
+ 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;
+ /* 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);
+ 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 {
- *--p = '#';
- *--p = '0' + base%10;
- if (base > 10)
- *--p = '0' + base/10;
- }
- if (negative)
- *--p = '-';
+ 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 {
+ *--p = '#';
+ *--p = '0' + base%10;
+ if (base > 10)
+ *--p = '0' + base/10;
+ }
+ if (negative)
+ *--p = '-';
- return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
+ return PyString_FromStringAndSize(p, &buf[sizeof(buf)] - p);
}
static PyObject *
int__format__(PyObject *self, PyObject *args)
{
- PyObject *format_spec;
+ 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 (!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;
+ if (str_spec == NULL)
+ return NULL;
- result = _PyInt_FormatAdvanced(self,
- PyBytes_AS_STRING(str_spec),
- PyBytes_GET_SIZE(str_spec));
+ 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;
+ Py_DECREF(str_spec);
+ return result;
+ }
+ PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode");
+ return NULL;
}
static PyObject *
int_bit_length(PyIntObject *v)
{
- unsigned long n;
+ unsigned long n;
- if (v->ob_ival < 0)
- /* avoid undefined behaviour when v->ob_ival == -LONG_MAX-1 */
- n = 0U-(unsigned long)v->ob_ival;
- else
- n = (unsigned long)v->ob_ival;
+ if (v->ob_ival < 0)
+ /* avoid undefined behaviour when v->ob_ival == -LONG_MAX-1 */
+ n = 0U-(unsigned long)v->ob_ival;
+ else
+ n = (unsigned long)v->ob_ival;
- return PyInt_FromLong(bits_in_ulong(n));
+ return PyInt_FromLong(bits_in_ulong(n));
}
PyDoc_STRVAR(int_bit_length_doc,
@@ -1287,44 +1287,44 @@
static PyObject *
int_is_finite(PyObject *v)
{
- Py_RETURN_TRUE;
+ Py_RETURN_TRUE;
}
#endif
static PyMethodDef int_methods[] = {
- {"conjugate", (PyCFunction)int_int, METH_NOARGS,
- "Returns self, the complex conjugate of any int."},
- {"bit_length", (PyCFunction)int_bit_length, METH_NOARGS,
- int_bit_length_doc},
+ {"conjugate", (PyCFunction)int_int, METH_NOARGS,
+ "Returns self, the complex conjugate of any int."},
+ {"bit_length", (PyCFunction)int_bit_length, METH_NOARGS,
+ int_bit_length_doc},
#if 0
- {"is_finite", (PyCFunction)int_is_finite, METH_NOARGS,
- "Returns always True."},
+ {"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 */
+ {"__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_get0, (setter)NULL,
- "the imaginary part of a complex number",
- NULL},
- {"numerator",
- (getter)int_int, (setter)NULL,
- "the numerator of a rational number in lowest terms",
- NULL},
- {"denominator",
- (getter)int_get1, (setter)NULL,
- "the denominator of a rational number in lowest terms",
- NULL},
- {NULL} /* Sentinel */
+ {"real",
+ (getter)int_int, (setter)NULL,
+ "the real part of a complex number",
+ NULL},
+ {"imag",
+ (getter)int_get0, (setter)NULL,
+ "the imaginary part of a complex number",
+ NULL},
+ {"numerator",
+ (getter)int_int, (setter)NULL,
+ "the numerator of a rational number in lowest terms",
+ NULL},
+ {"denominator",
+ (getter)int_get1, (setter)NULL,
+ "the denominator of a rational number in lowest terms",
+ NULL},
+ {NULL} /* Sentinel */
};
PyDoc_STRVAR(int_doc,
@@ -1339,212 +1339,212 @@
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 */
- (binaryfunc)int_true_divide, /* nb_true_divide */
- 0, /* nb_inplace_floor_divide */
- 0, /* nb_inplace_true_divide */
- (unaryfunc)int_int, /* nb_index */
+ (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 */
+ (binaryfunc)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_to_decimal_string, /* 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_to_decimal_string, /* 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 */
+ 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_to_decimal_string, /* 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_to_decimal_string, /* 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;
+ 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;
- }
+ 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;
+ return 1;
}
int
PyInt_ClearFreeList(void)
{
- PyIntObject *p;
- PyIntBlock *list, *next;
- int i;
- int u; /* remaining unfreed ints per block */
- int freelist_size = 0;
+ 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;
- }
+ 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;
- }
+ 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;
- }
+ }
+ }
+ else {
+ PyMem_FREE(list);
+ }
+ freelist_size += u;
+ list = next;
+ }
- return freelist_size;
+ return freelist_size;
}
void
PyInt_Fini(void)
{
- PyIntObject *p;
- PyIntBlock *list;
- int i;
- int u; /* total unfreed ints per block */
+ PyIntObject *p;
+ PyIntBlock *list;
+ int i;
+ int u; /* total unfreed ints per block */
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
- PyIntObject **q;
+ PyIntObject **q;
- i = NSMALLNEGINTS + NSMALLPOSINTS;
- q = small_ints;
- while (--i >= 0) {
- Py_XDECREF(*q);
- *q++ = NULL;
- }
+ 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,
- "# <int at %p, refcnt=%ld, val=%ld>\n",
- p, (long)p->ob_refcnt,
- p->ob_ival);
- }
- list = list->next;
- }
- }
+ 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,
+ "# <int at %p, refcnt=%ld, val=%ld>\n",
+ p, (long)p->ob_refcnt,
+ p->ob_ival);
+ }
+ list = list->next;
+ }
+ }
}