summaryrefslogtreecommitdiffstats
path: root/Objects/longobject.c
diff options
context:
space:
mode:
Diffstat (limited to 'Objects/longobject.c')
-rw-r--r--Objects/longobject.c708
1 files changed, 360 insertions, 348 deletions
diff --git a/Objects/longobject.c b/Objects/longobject.c
index dc84583..d95e86c 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -33,36 +33,37 @@ PERFORMANCE OF THIS SOFTWARE.
/* XXX The functional organization of this file is terrible */
-#include "allobjects.h"
+#include "Python.h"
#include "longintrepr.h"
#include "mymath.h"
+
#include <assert.h>
#include <ctype.h>
#define ABS(x) ((x) < 0 ? -(x) : (x))
/* Forward */
-static longobject *long_normalize PROTO((longobject *));
-static longobject *mul1 PROTO((longobject *, wdigit));
-static longobject *muladd1 PROTO((longobject *, wdigit, wdigit));
-static longobject *divrem1 PROTO((longobject *, wdigit, digit *));
-static object *long_format PROTO((object *aa, int base));
+static PyLongObject *long_normalize Py_PROTO((PyLongObject *));
+static PyLongObject *mul1 Py_PROTO((PyLongObject *, wdigit));
+static PyLongObject *muladd1 Py_PROTO((PyLongObject *, wdigit, wdigit));
+static PyLongObject *divrem1 Py_PROTO((PyLongObject *, wdigit, digit *));
+static PyObject *long_format Py_PROTO((PyObject *aa, int base));
static int ticker; /* XXX Could be shared with ceval? */
-#define SIGCHECK(block) \
+#define SIGCHECK(PyTryBlock) \
if (--ticker < 0) { \
ticker = 100; \
- if (sigcheck()) { block; } \
+ if (PyErr_CheckSignals()) { PyTryBlock; } \
}
/* Normalize (remove leading zeros from) a long int object.
Doesn't attempt to free the storage--in most cases, due to the nature
of the algorithms used, this could save at most be one word anyway. */
-static longobject *
+static PyLongObject *
long_normalize(v)
- register longobject *v;
+ register PyLongObject *v;
{
int j = ABS(v->ob_size);
register int i = j;
@@ -77,22 +78,22 @@ long_normalize(v)
/* Allocate a new long int object with size digits.
Return NULL and set exception if we run out of memory. */
-longobject *
-alloclongobject(size)
+PyLongObject *
+_PyLong_New(size)
int size;
{
- return NEWVAROBJ(longobject, &Longtype, size);
+ return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
}
/* Create a new long int object from a C long int */
-object *
-newlongobject(ival)
+PyObject *
+PyLong_FromLong(ival)
long ival;
{
/* Assume a C long fits in at most 5 'digits' */
/* Works on both 32- and 64-bit machines */
- longobject *v = alloclongobject(5);
+ PyLongObject *v = _PyLong_New(5);
if (v != NULL) {
unsigned long t = ival;
int i;
@@ -106,18 +107,18 @@ newlongobject(ival)
}
v = long_normalize(v);
}
- return (object *)v;
+ return (PyObject *)v;
}
/* Create a new long int object from a C unsigned long int */
-object *
+PyObject *
PyLong_FromUnsignedLong(ival)
unsigned long ival;
{
/* Assume a C long fits in at most 5 'digits' */
/* Works on both 32- and 64-bit machines */
- longobject *v = alloclongobject(5);
+ PyLongObject *v = _PyLong_New(5);
if (v != NULL) {
unsigned long t = ival;
int i;
@@ -127,20 +128,20 @@ PyLong_FromUnsignedLong(ival)
}
v = long_normalize(v);
}
- return (object *)v;
+ return (PyObject *)v;
}
/* Create a new long int object from a C double */
-object *
+PyObject *
#ifdef MPW
-dnewlongobject(double dval)
+PyLong_FromDouble(double dval)
#else
-dnewlongobject(dval)
+PyLong_FromDouble(dval)
double dval;
#endif /* MPW */
{
- longobject *v;
+ PyLongObject *v;
double frac;
int i, ndig, expo, neg;
neg = 0;
@@ -150,9 +151,9 @@ dnewlongobject(dval)
}
frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */
if (expo <= 0)
- return newlongobject(0L);
+ return PyLong_FromLong(0L);
ndig = (expo-1) / SHIFT + 1; /* Number of 'digits' in result */
- v = alloclongobject(ndig);
+ v = _PyLong_New(ndig);
if (v == NULL)
return NULL;
frac = ldexp(frac, (expo-1) % SHIFT + 1);
@@ -164,25 +165,25 @@ dnewlongobject(dval)
}
if (neg)
v->ob_size = -(v->ob_size);
- return (object *)v;
+ return (PyObject *)v;
}
/* Get a C long int from a long int object.
Returns -1 and sets an error condition if overflow occurs. */
long
-getlongvalue(vv)
- object *vv;
+PyLong_AsLong(vv)
+ PyObject *vv;
{
- register longobject *v;
+ register PyLongObject *v;
long x, prev;
int i, sign;
- if (vv == NULL || !is_longobject(vv)) {
- err_badcall();
+ if (vv == NULL || !PyLong_Check(vv)) {
+ PyErr_BadInternalCall();
return -1;
}
- v = (longobject *)vv;
+ v = (PyLongObject *)vv;
i = v->ob_size;
sign = 1;
x = 0;
@@ -194,7 +195,7 @@ getlongvalue(vv)
prev = x;
x = (x << SHIFT) + v->ob_digit[i];
if ((x >> SHIFT) != prev) {
- err_setstr(OverflowError,
+ PyErr_SetString(PyExc_OverflowError,
"long int too long to convert");
return -1;
}
@@ -207,21 +208,21 @@ getlongvalue(vv)
unsigned long
PyLong_AsUnsignedLong(vv)
- object *vv;
+ PyObject *vv;
{
- register longobject *v;
+ register PyLongObject *v;
unsigned long x, prev;
int i;
- if (vv == NULL || !is_longobject(vv)) {
- err_badcall();
+ if (vv == NULL || !PyLong_Check(vv)) {
+ PyErr_BadInternalCall();
return (unsigned long) -1;
}
- v = (longobject *)vv;
+ v = (PyLongObject *)vv;
i = v->ob_size;
x = 0;
if (i < 0) {
- err_setstr(OverflowError,
+ PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to unsigned long");
return (unsigned long) -1;
}
@@ -229,7 +230,7 @@ PyLong_AsUnsignedLong(vv)
prev = x;
x = (x << SHIFT) + v->ob_digit[i];
if ((x >> SHIFT) != prev) {
- err_setstr(OverflowError,
+ PyErr_SetString(PyExc_OverflowError,
"long int too long to convert");
return (unsigned long) -1;
}
@@ -240,19 +241,19 @@ PyLong_AsUnsignedLong(vv)
/* Get a C double from a long int object. */
double
-dgetlongvalue(vv)
- object *vv;
+PyLong_AsDouble(vv)
+ PyObject *vv;
{
- register longobject *v;
+ register PyLongObject *v;
double x;
double multiplier = (double) (1L << SHIFT);
int i, sign;
- if (vv == NULL || !is_longobject(vv)) {
- err_badcall();
+ if (vv == NULL || !PyLong_Check(vv)) {
+ PyErr_BadInternalCall();
return -1;
}
- v = (longobject *)vv;
+ v = (PyLongObject *)vv;
i = v->ob_size;
sign = 1;
x = 0.0;
@@ -268,9 +269,9 @@ dgetlongvalue(vv)
/* Multiply by a single digit, ignoring the sign. */
-static longobject *
+static PyLongObject *
mul1(a, n)
- longobject *a;
+ PyLongObject *a;
wdigit n;
{
return muladd1(a, n, (digit)0);
@@ -278,14 +279,14 @@ mul1(a, n)
/* Multiply by a single digit and add a single digit, ignoring the sign. */
-static longobject *
+static PyLongObject *
muladd1(a, n, extra)
- longobject *a;
+ PyLongObject *a;
wdigit n;
wdigit extra;
{
int size_a = ABS(a->ob_size);
- longobject *z = alloclongobject(size_a+1);
+ PyLongObject *z = _PyLong_New(size_a+1);
twodigits carry = extra;
int i;
@@ -304,19 +305,19 @@ muladd1(a, n, extra)
(as function result) and the remainder (through *prem).
The sign of a is ignored; n should not be zero. */
-static longobject *
+static PyLongObject *
divrem1(a, n, prem)
- longobject *a;
+ PyLongObject *a;
wdigit n;
digit *prem;
{
int size = ABS(a->ob_size);
- longobject *z;
+ PyLongObject *z;
int i;
twodigits rem = 0;
assert(n > 0 && n <= MASK);
- z = alloclongobject(size);
+ z = _PyLong_New(size);
if (z == NULL)
return NULL;
for (i = size; --i >= 0; ) {
@@ -333,21 +334,21 @@ divrem1(a, n, prem)
If base is 8 or 16, add the proper prefix '0' or '0x'.
External linkage: used in bltinmodule.c by hex() and oct(). */
-static object *
+static PyObject *
long_format(aa, base)
- object *aa;
+ PyObject *aa;
int base;
{
- register longobject *a = (longobject *)aa;
- stringobject *str;
+ register PyLongObject *a = (PyLongObject *)aa;
+ PyStringObject *str;
int i;
int size_a = ABS(a->ob_size);
char *p;
int bits;
char sign = '\0';
- if (a == NULL || !is_longobject(a)) {
- err_badcall();
+ if (a == NULL || !PyLong_Check(a)) {
+ PyErr_BadInternalCall();
return NULL;
}
assert(base >= 2 && base <= 36);
@@ -360,39 +361,39 @@ long_format(aa, base)
i >>= 1;
}
i = 6 + (size_a*SHIFT + bits-1) / bits;
- str = (stringobject *) newsizedstringobject((char *)0, i);
+ str = (PyStringObject *) PyString_FromStringAndSize((char *)0, i);
if (str == NULL)
return NULL;
- p = GETSTRINGVALUE(str) + i;
+ p = PyString_AS_STRING(str) + i;
*p = '\0';
*--p = 'L';
if (a->ob_size < 0)
sign = '-';
- INCREF(a);
+ Py_INCREF(a);
do {
digit rem;
- longobject *temp = divrem1(a, (digit)base, &rem);
+ PyLongObject *temp = divrem1(a, (digit)base, &rem);
if (temp == NULL) {
- DECREF(a);
- DECREF(str);
+ Py_DECREF(a);
+ Py_DECREF(str);
return NULL;
}
if (rem < 10)
rem += '0';
else
rem += 'A'-10;
- assert(p > GETSTRINGVALUE(str));
+ assert(p > PyString_AS_STRING(str));
*--p = (char) rem;
- DECREF(a);
+ Py_DECREF(a);
a = temp;
SIGCHECK({
- DECREF(a);
- DECREF(str);
+ Py_DECREF(a);
+ Py_DECREF(str);
return NULL;
})
} while (ABS(a->ob_size) != 0);
- DECREF(a);
+ Py_DECREF(a);
if (base == 8) {
if (size_a != 0)
*--p = '0';
@@ -409,15 +410,16 @@ long_format(aa, base)
}
if (sign)
*--p = sign;
- if (p != GETSTRINGVALUE(str)) {
- char *q = GETSTRINGVALUE(str);
+ if (p != PyString_AS_STRING(str)) {
+ char *q = PyString_AS_STRING(str);
assert(p > q);
do {
} while ((*q++ = *p++) != '\0');
q--;
- resizestring((object **)&str, (int) (q - GETSTRINGVALUE(str)));
+ _PyString_Resize((PyObject **)&str,
+ (int) (q - PyString_AS_STRING(str)));
}
- return (object *)str;
+ return (PyObject *)str;
}
#if 0
@@ -425,26 +427,27 @@ long_format(aa, base)
Base zero implies a default depending on the number.
External linkage: used in compile.c and stropmodule.c. */
-object *
+PyObject *
long_scan(str, base)
char *str;
int base;
{
- return long_escan(str, (char **)NULL, base);
+ return PyLong_FromString(str, (char **)NULL, base);
}
#endif
-object *
-long_escan(str, pend, base)
+PyObject *
+PyLong_FromString(str, pend, base)
char *str;
char **pend;
int base;
{
int sign = 1;
- longobject *z;
+ PyLongObject *z;
if ((base != 0 && base < 2) || base > 36) {
- err_setstr(ValueError, "invalid base for long literal");
+ PyErr_SetString(PyExc_ValueError,
+ "invalid base for long literal");
return NULL;
}
while (*str != '\0' && isspace(Py_CHARMASK(*str)))
@@ -467,10 +470,10 @@ long_escan(str, pend, base)
}
if (base == 16 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
str += 2;
- z = alloclongobject(0);
+ z = _PyLong_New(0);
for ( ; z != NULL; ++str) {
int k = -1;
- longobject *temp;
+ PyLongObject *temp;
if (*str <= '9')
k = *str - '0';
@@ -481,43 +484,44 @@ long_escan(str, pend, base)
if (k < 0 || k >= base)
break;
temp = muladd1(z, (digit)base, (digit)k);
- DECREF(z);
+ Py_DECREF(z);
z = temp;
}
if (sign < 0 && z != NULL && z->ob_size != 0)
z->ob_size = -(z->ob_size);
if (pend)
*pend = str;
- return (object *) z;
+ return (PyObject *) z;
}
-static longobject *x_divrem PROTO((longobject *, longobject *, longobject **));
-static object *long_pos PROTO((longobject *));
-static long_divrem PROTO((longobject *, longobject *,
- longobject **, longobject **));
+static PyLongObject *x_divrem
+ Py_PROTO((PyLongObject *, PyLongObject *, PyLongObject **));
+static PyObject *long_pos Py_PROTO((PyLongObject *));
+static long_divrem Py_PROTO((PyLongObject *, PyLongObject *,
+ PyLongObject **, PyLongObject **));
/* Long division with remainder, top-level routine */
static int
long_divrem(a, b, pdiv, prem)
- longobject *a, *b;
- longobject **pdiv;
- longobject **prem;
+ PyLongObject *a, *b;
+ PyLongObject **pdiv;
+ PyLongObject **prem;
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
- longobject *z;
+ PyLongObject *z;
if (size_b == 0) {
- err_setstr(ZeroDivisionError, "long division or modulo");
+ PyErr_SetString(PyExc_ZeroDivisionError, "long division or modulo");
return -1;
}
if (size_a < size_b ||
(size_a == size_b &&
a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) {
/* |a| < |b|. */
- *pdiv = alloclongobject(0);
- INCREF(a);
- *prem = (longobject *) a;
+ *pdiv = _PyLong_New(0);
+ Py_INCREF(a);
+ *prem = (PyLongObject *) a;
return 0;
}
if (size_b == 1) {
@@ -525,7 +529,7 @@ long_divrem(a, b, pdiv, prem)
z = divrem1(a, b->ob_digit[0], &rem);
if (z == NULL)
return -1;
- *prem = (longobject *) newlongobject((long)rem);
+ *prem = (PyLongObject *) PyLong_FromLong((long)rem);
}
else {
z = x_divrem(a, b, prem);
@@ -546,21 +550,21 @@ long_divrem(a, b, pdiv, prem)
/* Unsigned long division with remainder -- the algorithm */
-static longobject *
+static PyLongObject *
x_divrem(v1, w1, prem)
- longobject *v1, *w1;
- longobject **prem;
+ PyLongObject *v1, *w1;
+ PyLongObject **prem;
{
int size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
- longobject *v = mul1(v1, d);
- longobject *w = mul1(w1, d);
- longobject *a;
+ PyLongObject *v = mul1(v1, d);
+ PyLongObject *w = mul1(w1, d);
+ PyLongObject *a;
int j, k;
if (v == NULL || w == NULL) {
- XDECREF(v);
- XDECREF(w);
+ Py_XDECREF(v);
+ Py_XDECREF(w);
return NULL;
}
@@ -569,7 +573,7 @@ x_divrem(v1, w1, prem)
assert(size_w == ABS(w->ob_size)); /* That's how d was calculated */
size_v = ABS(v->ob_size);
- a = alloclongobject(size_v - size_w + 1);
+ a = _PyLong_New(size_v - size_w + 1);
for (j = size_v, k = a->ob_size-1; a != NULL && k >= 0; --j, --k) {
digit vj = (j >= size_v) ? 0 : v->ob_digit[j];
@@ -578,7 +582,7 @@ x_divrem(v1, w1, prem)
int i;
SIGCHECK({
- DECREF(a);
+ Py_DECREF(a);
a = NULL;
break;
})
@@ -600,7 +604,8 @@ x_divrem(v1, w1, prem)
for (i = 0; i < size_w && i+k < size_v; ++i) {
twodigits z = w->ob_digit[i] * q;
digit zz = (digit) (z >> SHIFT);
- carry += v->ob_digit[i+k] - z + ((twodigits)zz << SHIFT);
+ carry += v->ob_digit[i+k] - z
+ + ((twodigits)zz << SHIFT);
v->ob_digit[i+k] = carry & MASK;
carry = (carry >> SHIFT) - zz;
}
@@ -631,58 +636,59 @@ x_divrem(v1, w1, prem)
*prem = divrem1(v, d, &d);
/* d receives the (unused) remainder */
if (*prem == NULL) {
- DECREF(a);
+ Py_DECREF(a);
a = NULL;
}
}
- DECREF(v);
- DECREF(w);
+ Py_DECREF(v);
+ Py_DECREF(w);
return a;
}
/* Methods */
/* Forward */
-static void long_dealloc PROTO((object *));
-static object *long_repr PROTO((object *));
-static int long_compare PROTO((longobject *, longobject *));
-static long long_hash PROTO((longobject *));
-
-static object *long_add PROTO((longobject *, longobject *));
-static object *long_sub PROTO((longobject *, longobject *));
-static object *long_mul PROTO((longobject *, longobject *));
-static object *long_div PROTO((longobject *, longobject *));
-static object *long_mod PROTO((longobject *, longobject *));
-static object *long_divmod PROTO((longobject *, longobject *));
-static object *long_pow PROTO((longobject *, longobject *, longobject *));
-static object *long_neg PROTO((longobject *));
-static object *long_pos PROTO((longobject *));
-static object *long_abs PROTO((longobject *));
-static int long_nonzero PROTO((longobject *));
-static object *long_invert PROTO((longobject *));
-static object *long_lshift PROTO((longobject *, longobject *));
-static object *long_rshift PROTO((longobject *, longobject *));
-static object *long_and PROTO((longobject *, longobject *));
-static object *long_xor PROTO((longobject *, longobject *));
-static object *long_or PROTO((longobject *, longobject *));
+static void long_dealloc Py_PROTO((PyObject *));
+static PyObject *long_repr Py_PROTO((PyObject *));
+static int long_compare Py_PROTO((PyLongObject *, PyLongObject *));
+static long long_hash Py_PROTO((PyLongObject *));
+
+static PyObject *long_add Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_sub Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_mul Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_div Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_mod Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_divmod Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_pow
+ Py_PROTO((PyLongObject *, PyLongObject *, PyLongObject *));
+static PyObject *long_neg Py_PROTO((PyLongObject *));
+static PyObject *long_pos Py_PROTO((PyLongObject *));
+static PyObject *long_abs Py_PROTO((PyLongObject *));
+static int long_nonzero Py_PROTO((PyLongObject *));
+static PyObject *long_invert Py_PROTO((PyLongObject *));
+static PyObject *long_lshift Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_rshift Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_and Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_xor Py_PROTO((PyLongObject *, PyLongObject *));
+static PyObject *long_or Py_PROTO((PyLongObject *, PyLongObject *));
static void
long_dealloc(v)
- object *v;
+ PyObject *v;
{
- DEL(v);
+ PyMem_DEL(v);
}
-static object *
+static PyObject *
long_repr(v)
- object *v;
+ PyObject *v;
{
return long_format(v, 10);
}
static int
long_compare(a, b)
- longobject *a, *b;
+ PyLongObject *a, *b;
{
int sign;
@@ -709,7 +715,7 @@ long_compare(a, b)
static long
long_hash(v)
- longobject *v;
+ PyLongObject *v;
{
long x;
int i, sign;
@@ -738,22 +744,24 @@ long_hash(v)
/* Add the absolute values of two long integers. */
-static longobject *x_add PROTO((longobject *, longobject *));
-static longobject *
+static PyLongObject *x_add Py_PROTO((PyLongObject *, PyLongObject *));
+static PyLongObject *
x_add(a, b)
- longobject *a, *b;
+ PyLongObject *a, *b;
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
- longobject *z;
+ PyLongObject *z;
int i;
digit carry = 0;
/* Ensure a is the larger of the two: */
if (size_a < size_b) {
- { longobject *temp = a; a = b; b = temp; }
- { int size_temp = size_a; size_a = size_b; size_b = size_temp; }
+ { PyLongObject *temp = a; a = b; b = temp; }
+ { int size_temp = size_a;
+ size_a = size_b;
+ size_b = size_temp; }
}
- z = alloclongobject(size_a+1);
+ z = _PyLong_New(size_a+1);
if (z == NULL)
return NULL;
for (i = 0; i < size_b; ++i) {
@@ -774,13 +782,13 @@ x_add(a, b)
/* Subtract the absolute values of two integers. */
-static longobject *x_sub PROTO((longobject *, longobject *));
-static longobject *
+static PyLongObject *x_sub Py_PROTO((PyLongObject *, PyLongObject *));
+static PyLongObject *
x_sub(a, b)
- longobject *a, *b;
+ PyLongObject *a, *b;
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
- longobject *z;
+ PyLongObject *z;
int i;
int sign = 1;
digit borrow = 0;
@@ -788,8 +796,10 @@ x_sub(a, b)
/* Ensure a is the larger of the two: */
if (size_a < size_b) {
sign = -1;
- { longobject *temp = a; a = b; b = temp; }
- { int size_temp = size_a; size_a = size_b; size_b = size_temp; }
+ { PyLongObject *temp = a; a = b; b = temp; }
+ { int size_temp = size_a;
+ size_a = size_b;
+ size_b = size_temp; }
}
else if (size_a == size_b) {
/* Find highest digit where a and b differ: */
@@ -797,14 +807,14 @@ x_sub(a, b)
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
;
if (i < 0)
- return alloclongobject(0);
+ return _PyLong_New(0);
if (a->ob_digit[i] < b->ob_digit[i]) {
sign = -1;
- { longobject *temp = a; a = b; b = temp; }
+ { PyLongObject *temp = a; a = b; b = temp; }
}
size_a = size_b = i+1;
}
- z = alloclongobject(size_a);
+ z = _PyLong_New(size_a);
if (z == NULL)
return NULL;
for (i = 0; i < size_b; ++i) {
@@ -826,12 +836,12 @@ x_sub(a, b)
return long_normalize(z);
}
-static object *
+static PyObject *
long_add(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
- longobject *z;
+ PyLongObject *z;
if (a->ob_size < 0) {
if (b->ob_size < 0) {
@@ -848,15 +858,15 @@ long_add(a, b)
else
z = x_add(a, b);
}
- return (object *)z;
+ return (PyObject *)z;
}
-static object *
+static PyObject *
long_sub(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
- longobject *z;
+ PyLongObject *z;
if (a->ob_size < 0) {
if (b->ob_size < 0)
@@ -872,22 +882,22 @@ long_sub(a, b)
else
z = x_sub(a, b);
}
- return (object *)z;
+ return (PyObject *)z;
}
-static object *
+static PyObject *
long_mul(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
int size_a;
int size_b;
- longobject *z;
+ PyLongObject *z;
int i;
size_a = ABS(a->ob_size);
size_b = ABS(b->ob_size);
- z = alloclongobject(size_a + size_b);
+ z = _PyLong_New(size_a + size_b);
if (z == NULL)
return NULL;
for (i = 0; i < z->ob_size; ++i)
@@ -898,7 +908,7 @@ long_mul(a, b)
int j;
SIGCHECK({
- DECREF(z);
+ Py_DECREF(z);
return NULL;
})
for (j = 0; j < size_b; ++j) {
@@ -917,7 +927,7 @@ long_mul(a, b)
z->ob_size = -(z->ob_size);
if (b->ob_size < 0)
z->ob_size = -(z->ob_size);
- return (object *) long_normalize(z);
+ return (PyObject *) long_normalize(z);
}
/* The / and % operators are now defined in terms of divmod().
@@ -935,40 +945,40 @@ long_mul(a, b)
have different signs. We then subtract one from the 'div'
part of the outcome to keep the invariant intact. */
-static int l_divmod PROTO((longobject *, longobject *,
- longobject **, longobject **));
+static int l_divmod Py_PROTO((PyLongObject *, PyLongObject *,
+ PyLongObject **, PyLongObject **));
static int
l_divmod(v, w, pdiv, pmod)
- longobject *v;
- longobject *w;
- longobject **pdiv;
- longobject **pmod;
+ PyLongObject *v;
+ PyLongObject *w;
+ PyLongObject **pdiv;
+ PyLongObject **pmod;
{
- longobject *div, *mod;
+ PyLongObject *div, *mod;
if (long_divrem(v, w, &div, &mod) < 0)
return -1;
if ((mod->ob_size < 0 && w->ob_size > 0) ||
(mod->ob_size > 0 && w->ob_size < 0)) {
- longobject *temp;
- longobject *one;
- temp = (longobject *) long_add(mod, w);
- DECREF(mod);
+ PyLongObject *temp;
+ PyLongObject *one;
+ temp = (PyLongObject *) long_add(mod, w);
+ Py_DECREF(mod);
mod = temp;
if (mod == NULL) {
- DECREF(div);
+ Py_DECREF(div);
return -1;
}
- one = (longobject *) newlongobject(1L);
+ one = (PyLongObject *) PyLong_FromLong(1L);
if (one == NULL ||
- (temp = (longobject *) long_sub(div, one)) == NULL) {
- DECREF(mod);
- DECREF(div);
- XDECREF(one);
+ (temp = (PyLongObject *) long_sub(div, one)) == NULL) {
+ Py_DECREF(mod);
+ Py_DECREF(div);
+ Py_XDECREF(one);
return -1;
}
- DECREF(one);
- DECREF(div);
+ Py_DECREF(one);
+ Py_DECREF(div);
div = temp;
}
*pdiv = div;
@@ -976,81 +986,82 @@ l_divmod(v, w, pdiv, pmod)
return 0;
}
-static object *
+static PyObject *
long_div(v, w)
- longobject *v;
- longobject *w;
+ PyLongObject *v;
+ PyLongObject *w;
{
- longobject *div, *mod;
+ PyLongObject *div, *mod;
if (l_divmod(v, w, &div, &mod) < 0)
return NULL;
- DECREF(mod);
- return (object *)div;
+ Py_DECREF(mod);
+ return (PyObject *)div;
}
-static object *
+static PyObject *
long_mod(v, w)
- longobject *v;
- longobject *w;
+ PyLongObject *v;
+ PyLongObject *w;
{
- longobject *div, *mod;
+ PyLongObject *div, *mod;
if (l_divmod(v, w, &div, &mod) < 0)
return NULL;
- DECREF(div);
- return (object *)mod;
+ Py_DECREF(div);
+ return (PyObject *)mod;
}
-static object *
+static PyObject *
long_divmod(v, w)
- longobject *v;
- longobject *w;
+ PyLongObject *v;
+ PyLongObject *w;
{
- object *z;
- longobject *div, *mod;
+ PyObject *z;
+ PyLongObject *div, *mod;
if (l_divmod(v, w, &div, &mod) < 0)
return NULL;
- z = newtupleobject(2);
+ z = PyTuple_New(2);
if (z != NULL) {
- settupleitem(z, 0, (object *) div);
- settupleitem(z, 1, (object *) mod);
+ PyTuple_SetItem(z, 0, (PyObject *) div);
+ PyTuple_SetItem(z, 1, (PyObject *) mod);
}
else {
- DECREF(div);
- DECREF(mod);
+ Py_DECREF(div);
+ Py_DECREF(mod);
}
return z;
}
-static object *
+static PyObject *
long_pow(a, b, c)
- longobject *a;
- longobject *b;
- longobject *c;
+ PyLongObject *a;
+ PyLongObject *b;
+ PyLongObject *c;
{
- longobject *z, *div, *mod;
+ PyLongObject *z, *div, *mod;
int size_b, i;
size_b = b->ob_size;
if (size_b < 0) {
- err_setstr(ValueError, "long integer to the negative power");
+ PyErr_SetString(PyExc_ValueError,
+ "long integer to the negative power");
return NULL;
}
- z = (longobject *)newlongobject(1L);
- INCREF(a);
+ z = (PyLongObject *)PyLong_FromLong(1L);
+ Py_INCREF(a);
for (i = 0; i < size_b; ++i) {
digit bi = b->ob_digit[i];
int j;
for (j = 0; j < SHIFT; ++j) {
- longobject *temp;
+ PyLongObject *temp;
if (bi & 1) {
- temp = (longobject *)long_mul(z, a);
- DECREF(z);
- if ((object*)c!=None && temp!=NULL) {
+ temp = (PyLongObject *)long_mul(z, a);
+ Py_DECREF(z);
+ if ((PyObject*)c!=Py_None && temp!=NULL) {
l_divmod(temp, c, &div, &mod);
- XDECREF(div);
- DECREF(temp);
+ Py_XDECREF(div);
+ Py_DECREF(temp);
temp = mod;
}
z = temp;
@@ -1060,17 +1071,17 @@ long_pow(a, b, c)
bi >>= 1;
if (bi == 0 && i+1 == size_b)
break;
- temp = (longobject *)long_mul(a, a);
- DECREF(a);
- if ((object*)c!=None && temp!=NULL) {
+ temp = (PyLongObject *)long_mul(a, a);
+ Py_DECREF(a);
+ if ((PyObject*)c!=Py_None && temp!=NULL) {
l_divmod(temp, c, &div, &mod);
- XDECREF(div);
- DECREF(temp);
+ Py_XDECREF(div);
+ Py_DECREF(temp);
temp = mod;
}
a = temp;
if (a == NULL) {
- DECREF(z);
+ Py_DECREF(z);
z = NULL;
break;
}
@@ -1078,124 +1089,124 @@ long_pow(a, b, c)
if (a == NULL || z == NULL)
break;
}
- XDECREF(a);
- if ((object*)c!=None && z!=NULL) {
+ Py_XDECREF(a);
+ if ((PyObject*)c!=Py_None && z!=NULL) {
l_divmod(z, c, &div, &mod);
- XDECREF(div);
- DECREF(z);
+ Py_XDECREF(div);
+ Py_DECREF(z);
z=mod;
}
- return (object *)z;
+ return (PyObject *)z;
}
-static object *
+static PyObject *
long_invert(v)
- longobject *v;
+ PyLongObject *v;
{
/* Implement ~x as -(x+1) */
- longobject *x;
- longobject *w;
- w = (longobject *)newlongobject(1L);
+ PyLongObject *x;
+ PyLongObject *w;
+ w = (PyLongObject *)PyLong_FromLong(1L);
if (w == NULL)
return NULL;
- x = (longobject *) long_add(v, w);
- DECREF(w);
+ x = (PyLongObject *) long_add(v, w);
+ Py_DECREF(w);
if (x == NULL)
return NULL;
if (x->ob_size != 0)
x->ob_size = -(x->ob_size);
- return (object *)x;
+ return (PyObject *)x;
}
-static object *
+static PyObject *
long_pos(v)
- longobject *v;
+ PyLongObject *v;
{
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
}
-static object *
+static PyObject *
long_neg(v)
- longobject *v;
+ PyLongObject *v;
{
- longobject *z;
+ PyLongObject *z;
int i, n;
n = ABS(v->ob_size);
if (n == 0) {
/* -0 == 0 */
- INCREF(v);
- return (object *) v;
+ Py_INCREF(v);
+ return (PyObject *) v;
}
- z = alloclongobject(ABS(n));
+ z = _PyLong_New(ABS(n));
if (z == NULL)
return NULL;
for (i = 0; i < n; i++)
z->ob_digit[i] = v->ob_digit[i];
z->ob_size = -(v->ob_size);
- return (object *)z;
+ return (PyObject *)z;
}
-static object *
+static PyObject *
long_abs(v)
- longobject *v;
+ PyLongObject *v;
{
if (v->ob_size < 0)
return long_neg(v);
else {
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
}
}
static int
long_nonzero(v)
- longobject *v;
+ PyLongObject *v;
{
return ABS(v->ob_size) != 0;
}
-static object *
+static PyObject *
long_rshift(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
- longobject *z;
+ PyLongObject *z;
long shiftby;
int newsize, wordshift, loshift, hishift, i, j;
digit lomask, himask;
if (a->ob_size < 0) {
/* Right shifting negative numbers is harder */
- longobject *a1, *a2, *a3;
- a1 = (longobject *) long_invert(a);
+ PyLongObject *a1, *a2, *a3;
+ a1 = (PyLongObject *) long_invert(a);
if (a1 == NULL) return NULL;
- a2 = (longobject *) long_rshift(a1, b);
- DECREF(a1);
+ a2 = (PyLongObject *) long_rshift(a1, b);
+ Py_DECREF(a1);
if (a2 == NULL) return NULL;
- a3 = (longobject *) long_invert(a2);
- DECREF(a2);
- return (object *) a3;
+ a3 = (PyLongObject *) long_invert(a2);
+ Py_DECREF(a2);
+ return (PyObject *) a3;
}
- shiftby = getlongvalue((object *)b);
- if (shiftby == -1L && err_occurred())
+ shiftby = PyLong_AsLong((PyObject *)b);
+ if (shiftby == -1L && PyErr_Occurred())
return NULL;
if (shiftby < 0) {
- err_setstr(ValueError, "negative shift count");
+ PyErr_SetString(PyExc_ValueError, "negative shift count");
return NULL;
}
wordshift = shiftby / SHIFT;
newsize = ABS(a->ob_size) - wordshift;
if (newsize <= 0) {
- z = alloclongobject(0);
- return (object *)z;
+ z = _PyLong_New(0);
+ return (PyObject *)z;
}
loshift = shiftby % SHIFT;
hishift = SHIFT - loshift;
lomask = ((digit)1 << hishift) - 1;
himask = MASK ^ lomask;
- z = alloclongobject(newsize);
+ z = _PyLong_New(newsize);
if (z == NULL)
return NULL;
if (a->ob_size < 0)
@@ -1206,29 +1217,30 @@ long_rshift(a, b)
z->ob_digit[i] |=
(a->ob_digit[j+1] << hishift) & himask;
}
- return (object *) long_normalize(z);
+ return (PyObject *) long_normalize(z);
}
-static object *
+static PyObject *
long_lshift(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
/* This version due to Tim Peters */
- longobject *z;
+ PyLongObject *z;
long shiftby;
int oldsize, newsize, wordshift, remshift, i, j;
twodigits accum;
- shiftby = getlongvalue((object *)b);
- if (shiftby == -1L && err_occurred())
+ shiftby = PyLong_AsLong((PyObject *)b);
+ if (shiftby == -1L && PyErr_Occurred())
return NULL;
if (shiftby < 0) {
- err_setstr(ValueError, "negative shift count");
+ PyErr_SetString(PyExc_ValueError, "negative shift count");
return NULL;
}
if ((long)(int)shiftby != shiftby) {
- err_setstr(ValueError, "outrageous left shift count");
+ PyErr_SetString(PyExc_ValueError,
+ "outrageous left shift count");
return NULL;
}
/* wordshift, remshift = divmod(shiftby, SHIFT) */
@@ -1239,7 +1251,7 @@ long_lshift(a, b)
newsize = oldsize + wordshift;
if (remshift)
++newsize;
- z = alloclongobject(newsize);
+ z = _PyLong_New(newsize);
if (z == NULL)
return NULL;
if (a->ob_size < 0)
@@ -1256,7 +1268,7 @@ long_lshift(a, b)
z->ob_digit[newsize-1] = (digit)accum;
else
assert(!accum);
- return (object *) long_normalize(z);
+ return (PyObject *) long_normalize(z);
}
@@ -1265,46 +1277,46 @@ long_lshift(a, b)
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
-static object *long_bitwise PROTO((longobject *, int, longobject *));
-static object *
+static PyObject *long_bitwise Py_PROTO((PyLongObject *, int, PyLongObject *));
+static PyObject *
long_bitwise(a, op, b)
- longobject *a;
+ PyLongObject *a;
int op; /* '&', '|', '^' */
- longobject *b;
+ PyLongObject *b;
{
digit maska, maskb; /* 0 or MASK */
int negz;
int size_a, size_b, size_z;
- longobject *z;
+ PyLongObject *z;
int i;
digit diga, digb;
- object *v;
+ PyObject *v;
if (a->ob_size < 0) {
- a = (longobject *) long_invert(a);
+ a = (PyLongObject *) long_invert(a);
maska = MASK;
}
else {
- INCREF(a);
+ Py_INCREF(a);
maska = 0;
}
if (b->ob_size < 0) {
- b = (longobject *) long_invert(b);
+ b = (PyLongObject *) long_invert(b);
maskb = MASK;
}
else {
- INCREF(b);
+ Py_INCREF(b);
maskb = 0;
}
size_a = a->ob_size;
size_b = b->ob_size;
size_z = MAX(size_a, size_b);
- z = alloclongobject(size_z);
+ z = _PyLong_New(size_z);
if (a == NULL || b == NULL || z == NULL) {
- XDECREF(a);
- XDECREF(b);
- XDECREF(z);
+ Py_XDECREF(a);
+ Py_XDECREF(b);
+ Py_XDECREF(z);
return NULL;
}
@@ -1344,93 +1356,93 @@ long_bitwise(a, op, b)
}
}
- DECREF(a);
- DECREF(b);
+ Py_DECREF(a);
+ Py_DECREF(b);
z = long_normalize(z);
if (negz == 0)
- return (object *) z;
+ return (PyObject *) z;
v = long_invert(z);
- DECREF(z);
+ Py_DECREF(z);
return v;
}
-static object *
+static PyObject *
long_and(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
return long_bitwise(a, '&', b);
}
-static object *
+static PyObject *
long_xor(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
return long_bitwise(a, '^', b);
}
-static object *
+static PyObject *
long_or(a, b)
- longobject *a;
- longobject *b;
+ PyLongObject *a;
+ PyLongObject *b;
{
return long_bitwise(a, '|', b);
}
static int
long_coerce(pv, pw)
- object **pv;
- object **pw;
+ PyObject **pv;
+ PyObject **pw;
{
- if (is_intobject(*pw)) {
- *pw = newlongobject(getintvalue(*pw));
- INCREF(*pv);
+ if (PyInt_Check(*pw)) {
+ *pw = PyLong_FromLong(PyInt_AsLong(*pw));
+ Py_INCREF(*pv);
return 0;
}
return 1; /* Can't do it */
}
-static object *
+static PyObject *
long_int(v)
- object *v;
+ PyObject *v;
{
long x;
- x = getlongvalue(v);
- if (err_occurred())
+ x = PyLong_AsLong(v);
+ if (PyErr_Occurred())
return NULL;
- return newintobject(x);
+ return PyInt_FromLong(x);
}
-static object *
+static PyObject *
long_long(v)
- object *v;
+ PyObject *v;
{
- INCREF(v);
+ Py_INCREF(v);
return v;
}
-static object *
+static PyObject *
long_float(v)
- object *v;
+ PyObject *v;
{
double result;
PyFPE_START_PROTECT("long_float", return 0)
- result = dgetlongvalue(v);
+ result = PyLong_AsDouble(v);
PyFPE_END_PROTECT(result)
- return newfloatobject(result);
+ return PyFloat_FromDouble(result);
}
-static object *
+static PyObject *
long_oct(v)
- object *v;
+ PyObject *v;
{
return long_format(v, 8);
}
-static object *
+static PyObject *
long_hex(v)
- object *v;
+ PyObject *v;
{
return long_format(v, 16);
}
@@ -1441,7 +1453,7 @@ long_hex(v)
#define TF (ternaryfunc)
#define IF (inquiry)
-static number_methods long_as_number = {
+static PyNumberMethods long_as_number = {
BF long_add, /*nb_add*/
BF long_sub, /*nb_subtract*/
BF long_mul, /*nb_multiply*/
@@ -1459,7 +1471,7 @@ static number_methods long_as_number = {
BF long_and, /*nb_and*/
BF long_xor, /*nb_xor*/
BF long_or, /*nb_or*/
- (int (*) FPROTO((object **, object **)))
+ (int (*) Py_FPROTO((PyObject **, PyObject **)))
(coercion)long_coerce, /*nb_coerce*/
UF long_int, /*nb_int*/
UF long_long, /*nb_long*/
@@ -1468,22 +1480,22 @@ static number_methods long_as_number = {
UF long_hex, /*nb_hex*/
};
-typeobject Longtype = {
- OB_HEAD_INIT(&Typetype)
+PyTypeObject PyLong_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
0,
"long int",
- sizeof(longobject) - sizeof(digit),
+ sizeof(PyLongObject) - sizeof(digit),
sizeof(digit),
(destructor)long_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
- (int (*) FPROTO((object *, object *)))
+ (int (*) Py_FPROTO((PyObject *, PyObject *)))
(cmpfunc)long_compare, /*tp_compare*/
(reprfunc)long_repr, /*tp_repr*/
&long_as_number,/*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
- (long (*) FPROTO((object *)))
+ (long (*) Py_FPROTO((PyObject *)))
(hashfunc)long_hash, /*tp_hash*/
};