Initial revision
diff --git a/Objects/longobject.c b/Objects/longobject.c
new file mode 100644
index 0000000..e155608
--- /dev/null
+++ b/Objects/longobject.c
@@ -0,0 +1,900 @@
+/***********************************************************
+Copyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* Long (arbitrary precision) integer object implementation */
+
+#include "allobjects.h"
+#include "longintrepr.h"
+#include <assert.h>
+
+/* 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. */
+
+longobject *
+long_normalize(v)
+ register longobject *v;
+{
+ int j = ABS(v->ob_size);
+ register int i = j;
+
+ while (i > 0 && v->ob_digit[i-1] == 0)
+ --i;
+ if (i != j)
+ v->ob_size = (v->ob_size < 0) ? -i : i;
+ return v;
+}
+
+/* Allocate a new long int object with size digits.
+ Return NULL and set exception if we run out of memory. */
+
+longobject *
+alloclongobject(size)
+ int size;
+{
+ return NEWVAROBJ(longobject, &Longtype, size);
+}
+
+/* Create a new long int object from a C long int */
+
+object *
+newlongobject(ival)
+ long ival;
+{
+ /* Assume a C long fits in at most 3 'digits' */
+ longobject *v = alloclongobject(3);
+ if (v != NULL) {
+ if (ival < 0) {
+ ival = -ival;
+ v->ob_size = -v->ob_size;
+ }
+ v->ob_digit[0] = ival & MASK;
+ v->ob_digit[1] = (ival >> SHIFT) & MASK;
+ v->ob_digit[2] = (ival >> (2*SHIFT)) & MASK;
+ v = long_normalize(v);
+ }
+ return (object *)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;
+{
+ register longobject *v;
+ long x, prev;
+ int i, sign;
+
+ if (vv == NULL || !is_longobject(vv)) {
+ err_badcall();
+ return -1;
+ }
+ v = (longobject *)vv;
+ i = v->ob_size;
+ sign = 1;
+ x = 0;
+ if (i < 0) {
+ sign = -1;
+ i = -i;
+ }
+ while (--i >= 0) {
+ prev = x;
+ x = (x << SHIFT) + v->ob_digit[i];
+ if ((x >> SHIFT) != prev) {
+ err_setstr(RuntimeError,
+ "long int too long to convert");
+ return -1;
+ }
+ }
+ return x * sign;
+}
+
+/* Get a C double from a long int object. No overflow check. */
+
+double
+dgetlongvalue(vv)
+ object *vv;
+{
+ register longobject *v;
+ double x;
+ double multiplier = (double) (1L << SHIFT);
+ int i, sign;
+
+ if (vv == NULL || !is_longobject(vv)) {
+ err_badcall();
+ return -1;
+ }
+ v = (longobject *)vv;
+ i = v->ob_size;
+ sign = 1;
+ x = 0.0;
+ if (i < 0) {
+ sign = -1;
+ i = -i;
+ }
+ while (--i >= 0) {
+ x = x*multiplier + v->ob_digit[i];
+ }
+ return x * sign;
+}
+
+/* Multiply by a single digit, ignoring the sign. */
+
+longobject *
+mul1(a, n)
+ longobject *a;
+ digit n;
+{
+ return muladd1(a, n, (digit)0);
+}
+
+/* Multiply by a single digit and add a single digit, ignoring the sign. */
+
+longobject *
+muladd1(a, n, extra)
+ longobject *a;
+ digit n;
+ digit extra;
+{
+ int size_a = ABS(a->ob_size);
+ longobject *z = alloclongobject(size_a+1);
+ twodigits carry = extra;
+ int i;
+
+ if (z == NULL)
+ return NULL;
+ for (i = 0; i < size_a; ++i) {
+ carry += (twodigits)a->ob_digit[i] * n;
+ z->ob_digit[i] = carry & MASK;
+ carry >>= SHIFT;
+ }
+ z->ob_digit[i] = carry;
+ return long_normalize(z);
+}
+
+/* Divide a long integer by a digit, returning both the quotient
+ (as function result) and the remainder (through *prem).
+ The sign of a is ignored; n should not be zero. */
+
+longobject *
+divrem1(a, n, prem)
+ longobject *a;
+ digit n;
+ digit *prem;
+{
+ int size = ABS(a->ob_size);
+ longobject *z;
+ int i;
+ twodigits rem = 0;
+
+ assert(n > 0 && n <= MASK);
+ z = alloclongobject(size);
+ if (z == NULL)
+ return NULL;
+ for (i = size; --i >= 0; ) {
+ rem = (rem << SHIFT) + a->ob_digit[i];
+ z->ob_digit[i] = rem/n;
+ rem %= n;
+ }
+ *prem = rem;
+ return long_normalize(z);
+}
+
+/* Convert a long int object to a string, using a given conversion base.
+ Return a string object. */
+
+stringobject *
+long_format(a, base)
+ longobject *a;
+ int base;
+{
+ stringobject *str;
+ int i;
+ int size_a = ABS(a->ob_size);
+ char *p;
+ int bits;
+ char sign = '\0';
+
+ assert(base >= 2 && base <= 36);
+
+ /* Compute a rough upper bound for the length of the string */
+ i = base;
+ bits = 0;
+ while (i > 1) {
+ ++bits;
+ i >>= 1;
+ }
+ i = 1 + (size_a*SHIFT + bits-1) / bits;
+ str = (stringobject *) newsizedstringobject((char *)0, i);
+ if (str == NULL)
+ return NULL;
+ p = GETSTRINGVALUE(str) + i;
+ *p = '\0';
+ if (a->ob_size < 0)
+ sign = '-';
+
+ INCREF(a);
+ do {
+ digit rem;
+ longobject *temp = divrem1(a, (digit)base, &rem);
+ if (temp == NULL) {
+ DECREF(a);
+ DECREF(str);
+ return NULL;
+ }
+ if (rem < 10)
+ rem += '0';
+ else
+ rem += 'A'-10;
+ assert(p > GETSTRINGVALUE(str));
+ *--p = rem;
+ DECREF(a);
+ a = temp;
+ if (a->ob_size >= INTRLIMIT && intrcheck()) {
+ DECREF(a);
+ DECREF(str);
+ err_set(KeyboardInterrupt);
+ return NULL;
+ }
+ } while (a->ob_size != 0);
+ DECREF(a);
+ if (sign)
+ *--p = sign;
+ if (p != GETSTRINGVALUE(str)) {
+ char *q = GETSTRINGVALUE(str);
+ assert(p > q);
+ do {
+ } while ((*q++ = *p++) != '\0');
+ resizestring((object **)&str, (int) (q - GETSTRINGVALUE(str)));
+ }
+ return str;
+}
+
+/* Convert a string to a long int object, in a given base.
+ Base zero implies a default depending on the number. */
+
+object *
+long_scan(str, base)
+ char *str;
+ int base;
+{
+ int sign = 1;
+ longobject *z;
+
+ assert(base == 0 || base >= 2 && base <= 36);
+ if (*str == '+')
+ ++str;
+ else if (*str == '-') {
+ ++str;
+ sign = -1;
+ }
+ if (base == 0) {
+ if (str[0] != '0')
+ base = 10;
+ else if (str[1] == 'x' || str[1] == 'X')
+ base = 16;
+ else
+ base = 8;
+ }
+ if (base == 16 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
+ str += 2;
+ z = alloclongobject(0);
+ for ( ; z != NULL; ++str) {
+ int k = -1;
+ longobject *temp;
+
+ if (*str <= '9')
+ k = *str - '0';
+ else if (*str >= 'a')
+ k = *str - 'a' + 10;
+ else if (*str >= 'A')
+ k = *str - 'A' + 10;
+ if (k < 0 || k >= base)
+ break;
+ temp = muladd1(z, (digit)base, (digit)k);
+ DECREF(z);
+ z = temp;
+ }
+ if (z != NULL)
+ z->ob_size *= sign;
+ return (object *) z;
+}
+
+static longobject *x_divrem PROTO((longobject *, longobject *, longobject **));
+
+/* Long division with remainder, top-level routine */
+
+longobject *
+long_divrem(a, b, prem)
+ longobject *a, *b;
+ longobject **prem;
+{
+ int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+ longobject *z;
+
+ if (size_b == 0) {
+ if (prem != NULL)
+ *prem = NULL;
+ err_setstr(RuntimeError, "long division by zero");
+ return NULL;
+ }
+ if (size_a < size_b ||
+ size_a == size_b && a->ob_digit[size_a-1] < b->ob_digit[size_b-1]) {
+ /* |a| < |b|. */
+ if (prem != NULL) {
+ INCREF(a);
+ *prem = a;
+ }
+ return alloclongobject(0);
+ }
+ if (size_b == 1) {
+ digit rem = 0;
+ z = divrem1(a, b->ob_digit[0], &rem);
+ if (prem != NULL) {
+ if (z == NULL)
+ *prem = NULL;
+ else
+ *prem = (longobject *)
+ newlongobject((long)rem);
+ }
+ }
+ else
+ z = x_divrem(a, b, prem);
+ /* Set the signs.
+ The quotient z has the sign of a*b;
+ the remainder r has the sign of a,
+ so a = b*z + r. */
+ if (z != NULL) {
+ if ((a->ob_size < 0) != (b->ob_size < 0))
+ z->ob_size = - z->ob_size;
+ if (prem != NULL && *prem != NULL && a->ob_size < 0)
+ (*prem)->ob_size = - (*prem)->ob_size;
+ }
+ return z;
+}
+
+/* True unsigned long division with remainder */
+
+static longobject *
+x_divrem(v1, w1, prem)
+ longobject *v1, *w1;
+ longobject **prem;
+{
+ int size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
+ digit d = (twodigits)BASE / (w1->ob_digit[size_w-1] + 1);
+ longobject *v = mul1(v1, d);
+ longobject *w = mul1(w1, d);
+ longobject *a;
+ int j, k;
+
+ if (v == NULL || w == NULL) {
+ XDECREF(v);
+ XDECREF(w);
+ if (prem != NULL)
+ *prem = NULL;
+ return NULL;
+ }
+
+ assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
+ assert(v->refcnt == 1); /* Since v will be used as accumulator! */
+ 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);
+
+ 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];
+ twodigits q;
+ long carry = 0; /* Signed! long! */
+ int i;
+
+ if (size_v >= INTRLIMIT && intrcheck()) {
+ DECREF(a);
+ a = NULL;
+ err_set(KeyboardInterrupt);
+ break;
+ }
+ if (vj == w->ob_digit[size_w-1])
+ q = MASK;
+ else
+ q = (((twodigits)vj << SHIFT) + v->ob_digit[j-1]) /
+ w->ob_digit[size_w-1];
+
+ while (w->ob_digit[size_w-2]*q >
+ ((
+ ((twodigits)vj << SHIFT)
+ + v->ob_digit[j-1]
+ - q*w->ob_digit[size_w-1]
+ ) << SHIFT)
+ + v->ob_digit[j-2])
+ --q;
+
+ for (i = 0; i < size_w && i+k < size_v; ++i) {
+ twodigits z = w->ob_digit[i] * q;
+ digit zz = z >> SHIFT;
+ carry += v->ob_digit[i+k] - z + ((twodigits)zz << SHIFT);
+ v->ob_digit[i+k] = carry & MASK;
+ carry = (carry >> SHIFT) - zz;
+ }
+
+ if (i+k < size_v) {
+ carry += v->ob_digit[i+k];
+ v->ob_digit[i+k] = 0;
+ }
+
+ if (carry == 0)
+ a->ob_digit[k] = q;
+ else {
+ assert(carry == -1);
+ a->ob_digit[k] = q-1;
+ carry = 0;
+ for (i = 0; i < size_w && i+k < size_v; ++i) {
+ carry += v->ob_digit[i+k] + w->ob_digit[i];
+ v->ob_digit[i+k] = carry & MASK;
+ carry >>= SHIFT;
+ }
+ }
+ } /* for j, k */
+
+ if (a != NULL)
+ a = long_normalize(a);
+ if (prem != 0) {
+ if (a == NULL)
+ *prem = NULL;
+ else
+ *prem = divrem1(v, d, &d);
+ /* Using d as a dummy to receive the - unused - remainder */
+ }
+ DECREF(v);
+ DECREF(w);
+ return a;
+}
+
+/* Methods */
+
+static void
+long_dealloc(v)
+ longobject *v;
+{
+ DEL(v);
+}
+
+static void
+long_print(v, fp, flags)
+ longobject *v;
+ FILE *fp;
+ int flags;
+{
+ stringobject *str = long_format(v, 10);
+ if (str == NULL) {
+ err_clear();
+ fprintf(fp, "[err]");
+ }
+ else {
+ fprintf(fp, "%sL", GETSTRINGVALUE(str));
+ DECREF(str);
+ }
+}
+
+static object *
+long_repr(v)
+ longobject *v;
+{
+ stringobject *str = long_format(v, 10);
+ if (str != NULL) {
+ int len = getstringsize((object *)str);
+ resizestring((object **)&str, len + 1);
+ if (str != NULL)
+ GETSTRINGVALUE(str)[len] = 'L';
+ }
+ return (object *)str;
+}
+
+static int
+long_compare(a, b)
+ longobject *a, *b;
+{
+ int sign;
+
+ if (a->ob_size != b->ob_size)
+ sign = a->ob_size - b->ob_size;
+ else {
+ int i = ABS(a->ob_size);
+ while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
+ ;
+ if (i < 0)
+ sign = 0;
+ else
+ sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
+ }
+ return sign;
+}
+
+/* Add the absolute values of two long integers. */
+
+static longobject *x_add PROTO((longobject *, longobject *));
+static longobject *
+x_add(a, b)
+ longobject *a, *b;
+{
+ int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+ longobject *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; }
+ }
+ z = alloclongobject(size_a+1);
+ if (z == NULL)
+ return NULL;
+ for (i = 0; i < size_b; ++i) {
+ carry += a->ob_digit[i] + b->ob_digit[i];
+ z->ob_digit[i] = carry & MASK;
+ /* The following assumes unsigned shifts don't
+ propagate the sign bit. */
+ carry >>= SHIFT;
+ }
+ for (; i < size_a; ++i) {
+ carry += a->ob_digit[i];
+ z->ob_digit[i] = carry & MASK;
+ carry >>= SHIFT;
+ }
+ z->ob_digit[i] = carry;
+ return long_normalize(z);
+}
+
+/* Subtract the absolute values of two integers. */
+
+static longobject *x_sub PROTO((longobject *, longobject *));
+static longobject *
+x_sub(a, b)
+ longobject *a, *b;
+{
+ int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
+ longobject *z;
+ int i;
+ int sign = 1;
+ digit borrow = 0;
+
+ /* 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; }
+ }
+ else if (size_a == size_b) {
+ /* Find highest digit where a and b differ: */
+ i = size_a;
+ while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
+ ;
+ if (i < 0)
+ return alloclongobject(0);
+ if (a->ob_digit[i] < b->ob_digit[i]) {
+ sign = -1;
+ { longobject *temp = a; a = b; b = temp; }
+ }
+ size_a = size_b = i+1;
+ }
+ z = alloclongobject(size_a);
+ if (z == NULL)
+ return NULL;
+ for (i = 0; i < size_b; ++i) {
+ /* The following assumes unsigned arithmetic
+ works module 2**N for some N>SHIFT. */
+ borrow = a->ob_digit[i] - b->ob_digit[i] - borrow;
+ z->ob_digit[i] = borrow & MASK;
+ borrow >>= SHIFT;
+ borrow &= 1; /* Keep only one sign bit */
+ }
+ for (; i < size_a; ++i) {
+ borrow = a->ob_digit[i] - borrow;
+ z->ob_digit[i] = borrow & MASK;
+ borrow >>= SHIFT;
+ }
+ assert(borrow == 0);
+ z->ob_size *= sign;
+ return long_normalize(z);
+}
+
+static object *
+long_add(a, w)
+ longobject *a;
+ object *w;
+{
+ longobject *b;
+ longobject *z;
+
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ b = (longobject *)w;
+
+ if (a->ob_size < 0) {
+ if (b->ob_size < 0) {
+ z = x_add(a, b);
+ if (z != NULL)
+ z->ob_size = -z->ob_size;
+ }
+ else
+ z = x_sub(b, a);
+ }
+ else {
+ if (b->ob_size < 0)
+ z = x_sub(a, b);
+ else
+ z = x_add(a, b);
+ }
+ return (object *)z;
+}
+
+static object *
+long_sub(a, w)
+ longobject *a;
+ object *w;
+{
+ longobject *b;
+ longobject *z;
+
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ b = (longobject *)w;
+
+ if (a->ob_size < 0) {
+ if (b->ob_size < 0)
+ z = x_sub(a, b);
+ else
+ z = x_add(a, b);
+ if (z != NULL)
+ z->ob_size = -z->ob_size;
+ }
+ else {
+ if (b->ob_size < 0)
+ z = x_add(a, b);
+ else
+ z = x_sub(a, b);
+ }
+ return (object *)z;
+}
+
+static object *
+long_mul(a, w)
+ longobject *a;
+ object *w;
+{
+ longobject *b;
+ int size_a;
+ int size_b;
+ longobject *z;
+ int i;
+
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ b = (longobject *)w;
+ size_a = ABS(a->ob_size);
+ size_b = ABS(b->ob_size);
+ z = alloclongobject(size_a + size_b);
+ if (z == NULL)
+ return NULL;
+ for (i = 0; i < z->ob_size; ++i)
+ z->ob_digit[i] = 0;
+ for (i = 0; i < size_a; ++i) {
+ twodigits carry = 0;
+ twodigits f = a->ob_digit[i];
+ int j;
+
+ if (z->ob_size >= INTRLIMIT && intrcheck()) {
+ DECREF(z);
+ err_set(KeyboardInterrupt);
+ return NULL;
+ }
+ for (j = 0; j < size_b; ++j) {
+ carry += z->ob_digit[i+j] + b->ob_digit[j] * f;
+ z->ob_digit[i+j] = carry & MASK;
+ carry >>= SHIFT;
+ }
+ for (; carry != 0; ++j) {
+ assert(i+j < z->ob_size);
+ carry += z->ob_digit[i+j];
+ z->ob_digit[i+j] = carry & MASK;
+ carry >>= SHIFT;
+ }
+ }
+ if (a->ob_size < 0)
+ z->ob_size = -z->ob_size;
+ if (b->ob_size < 0)
+ z->ob_size = -z->ob_size;
+ return (object *) long_normalize(z);
+}
+
+static object *
+long_div(v, w)
+ longobject *v;
+ register object *w;
+{
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ return (object *) long_divrem(v, (longobject *)w, (longobject **)0);
+}
+
+static object *
+long_rem(v, w)
+ longobject *v;
+ register object *w;
+{
+ longobject *div, *rem = NULL;
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ div = long_divrem(v, (longobject *)w, &rem);
+ if (div == NULL) {
+ XDECREF(rem);
+ rem = NULL;
+ }
+ else {
+ DECREF(div);
+ }
+ return (object *) rem;
+}
+
+/* The expression a mod b has the value a - b*floor(a/b).
+ The divrem function gives the remainder after division of
+ |a| by |b|, with the sign of a. This is also expressed
+ as a - b*trunc(a/b), if trunc truncates towards zero.
+ Some examples:
+ a b a rem b a mod b
+ 13 10 3 3
+ -13 10 -3 7
+ 13 -10 3 -7
+ -13 -10 -3 -3
+ So, to get from rem to mod, we have to add b if a and b
+ have different signs. */
+
+static object *
+long_divmod(v, w)
+ longobject *v;
+ register object *w;
+{
+ object *z;
+ longobject *div, *rem;
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ div = long_divrem(v, (longobject *)w, &rem);
+ if (div == NULL) {
+ XDECREF(rem);
+ return NULL;
+ }
+ if ((v->ob_size < 0) != (((longobject *)w)->ob_size < 0)) {
+ longobject *temp = (longobject *) long_add(rem, w);
+ DECREF(rem);
+ rem = temp; /* XXX ??? was rem = b ??? */
+ if (rem == NULL) {
+ DECREF(div);
+ return NULL;
+ }
+ }
+ z = newtupleobject(2);
+ if (z != NULL) {
+ settupleitem(z, 0, (object *) div);
+ settupleitem(z, 1, (object *) rem);
+ }
+ else {
+ DECREF(div);
+ DECREF(rem);
+ }
+ return z;
+}
+
+static object *
+long_pow(v, w)
+ longobject *v;
+ register object *w;
+{
+ if (!is_longobject(w)) {
+ err_badarg();
+ return NULL;
+ }
+ err_setstr(SystemError, "long power not implemented");
+ return NULL;
+}
+
+static object *
+long_pos(v)
+ longobject *v;
+{
+ INCREF(v);
+ return (object *)v;
+}
+
+static object *
+long_neg(v)
+ longobject *v;
+{
+ longobject *z;
+ int i = v->ob_size;
+ if (i == 0)
+ return long_pos(v);
+ i = ABS(i);
+ z = alloclongobject(i);
+ if (z != NULL) {
+ z->ob_size = - v->ob_size;
+ while (--i >= 0)
+ z->ob_digit[i] = v->ob_digit[i];
+ }
+ return (object *)z;
+}
+
+static object *
+long_abs(v)
+ longobject *v;
+{
+ if (v->ob_size < 0)
+ return long_neg(v);
+ else
+ return long_pos(v);
+}
+
+static number_methods long_as_number = {
+ long_add, /*nb_add*/
+ long_sub, /*nb_subtract*/
+ long_mul, /*nb_multiply*/
+ long_div, /*nb_divide*/
+ long_rem, /*nb_remainder*/
+ long_divmod, /*nb_divmod*/
+ long_pow, /*nb_power*/
+ long_neg, /*nb_negative*/
+ long_pos, /*tp_positive*/
+ long_abs, /*tp_absolute*/
+};
+
+typeobject Longtype = {
+ OB_HEAD_INIT(&Typetype)
+ 0,
+ "long int",
+ sizeof(longobject) - sizeof(digit),
+ sizeof(digit),
+ long_dealloc, /*tp_dealloc*/
+ long_print, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ long_compare, /*tp_compare*/
+ long_repr, /*tp_repr*/
+ &long_as_number,/*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+};