/* MPZ objects */
-#include "allobjects.h"
+#include "Python.h"
#include <assert.h>
#include <sys/types.h> /* For size_t */
#endif
typedef struct {
- OB_HEAD
+ PyObject_HEAD
MP_INT mpz; /* the actual number */
} mpzobject;
-staticforward typeobject MPZtype;
+staticforward PyTypeObject MPZtype;
#define is_mpzobject(v) ((v)->ob_type == &MPZtype)
#ifdef MPZ_DEBUG
fputs( "mpz_object() called...\n", stderr );
#endif /* def MPZ_DEBUG */
- mpzp = NEWOBJ(mpzobject, &MPZtype);
+ mpzp = PyObject_NEW(mpzobject, &MPZtype);
if (mpzp == NULL)
return NULL;
#include "longlong.h"
#endif /* def MPZ_GET_STR_BUG */
-static object *
+static PyObject *
mpz_format(objp, base, withname)
- object *objp;
+ PyObject *objp;
int base;
unsigned char withname;
{
mpzobject *mpzp = (mpzobject *)objp;
- stringobject *strobjp;
+ PyStringObject *strobjp;
int i;
int cmpres;
int taglong;
tcp = &prefix[0];
if (mpzp == NULL || !is_mpzobject(mpzp)) {
- err_badcall();
+ PyErr_BadInternalCall();
return NULL;
}
#ifdef MPZ_DEBUG
fprintf(stderr, "mpz_format: requesting string size %d\n", i);
#endif /* def MPZ_DEBUG */
- if ((strobjp = (stringobject *)newsizedstringobject((char *)0, i))
+ if ((strobjp =
+ (PyStringObject *)PyString_FromStringAndSize((char *)0, i))
== NULL)
return NULL;
/* get the beginning of the string memory and start copying things */
- cp = GETSTRINGVALUE(strobjp);
+ cp = PyString_AS_STRING(strobjp);
if (withname) {
strcpy(cp, initialiser_name);
cp += strlen(initialiser_name);
cp += tcp - prefix;
/* since' we have the sign already, let the lib think it's a positive
- number */
+ number */
if (cmpres < 0)
mpz_neg(&mpzp->mpz,&mpzp->mpz); /* hack Hack HAck HACk HACK */
(void)mpz_get_str(cp, base, &mpzp->mpz);
#ifdef MPZ_DEBUG
fprintf(stderr,
"mpz_format: cp (str end) 0x%x, begin 0x%x, diff %d, i %d\n",
- cp, GETSTRINGVALUE(strobjp), cp - GETSTRINGVALUE(strobjp), i);
+ cp, PyString_AS_STRING(strobjp),
+ cp - PyString_AS_STRING(strobjp), i);
#endif /* def MPZ_DEBUG */
- assert(cp - GETSTRINGVALUE(strobjp) <= i);
+ assert(cp - PyString_AS_STRING(strobjp) <= i);
- if (cp - GETSTRINGVALUE(strobjp) != i) {
- strobjp->ob_size -= i - (cp - GETSTRINGVALUE(strobjp));
+ if (cp - PyString_AS_STRING(strobjp) != i) {
+ strobjp->ob_size -= i - (cp - PyString_AS_STRING(strobjp));
}
- return (object *)strobjp;
+ return (PyObject *)strobjp;
} /* mpz_format() */
/* MPZ methods */
fputs( "mpz_dealloc() called...\n", stderr );
#endif /* def MPZ_DEBUG */
mpz_clear(&mpzp->mpz);
- DEL(mpzp);
+ PyMem_DEL(mpzp);
} /* mpz_dealloc() */
: cmpres > 0 ? 1 : -1;
} /* mpz_compare() */
-static object *
+static PyObject *
mpz_addition(a, b)
mpzobject *a;
mpzobject *b;
#ifdef MPZ_SPARE_MALLOC
if (mpz_cmp_ui(&a->mpz, (unsigned long int)0) == 0) {
- INCREF(b);
- return (object *)b;
+ Py_INCREF(b);
+ return (PyObject *)b;
}
if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
#endif /* def MPZ_SPARE_MALLOC */
return NULL;
mpz_add(&z->mpz, &a->mpz, &b->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_addition() */
-static object *
+static PyObject *
mpz_substract(a, b)
mpzobject *a;
mpzobject *b;
#ifdef MPZ_SPARE_MALLOC
if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
#endif /* MPZ_SPARE_MALLOC */
return NULL;
mpz_sub(&z->mpz, &a->mpz, &b->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_substract() */
-static object *
+static PyObject *
mpz_multiply(a, b)
mpzobject *a;
mpzobject *b;
#ifdef MPZ_SPARE_MALLOC
if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) {
- INCREF(mpz_value_zero);
- return (object *)mpz_value_zero;
+ Py_INCREF(mpz_value_zero);
+ return (PyObject *)mpz_value_zero;
}
if (cmpres > 0 && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) {
- INCREF(b);
- return (object *)b;
+ Py_INCREF(b);
+ return (PyObject *)b;
}
if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long_int)0)) == 0) {
- INCREF(mpz_value_zero);
- return (object *)mpz_value_zero;
+ Py_INCREF(mpz_value_zero);
+ return (PyObject *)mpz_value_zero;
}
if (cmpres > 0 && mpz_cmp_ui(&b->mpz, (unsigned long int)1) == 0) {
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
#endif /* MPZ_SPARE_MALLOC */
return NULL;
mpz_mul( &z->mpz, &a->mpz, &b->mpz );
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_multiply() */
-static object *
+static PyObject *
mpz_divide(a, b)
mpzobject *a;
mpzobject *b;
cmpres =
#endif /* def MPZ_SPARE_MALLOC */
mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
- err_setstr(ZeroDivisionError, "mpz./ by zero");
+ PyErr_SetString(PyExc_ZeroDivisionError, "mpz./ by zero");
return NULL;
}
#ifdef MPZ_SPARE_MALLOC
if (cmpres > 0 && mpz_cmp_ui(&b->mpz(unsigned long int)1) == 0) {
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
#endif /* def MPZ_SPARE_MALLOC */
mpz_out_str(stderr, 10, &z->mpz);
putc('\n', stderr);
#endif /* def MPZ_TEST_DIV */
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_divide() */
-static object *
+static PyObject *
mpz_remainder(a, b)
mpzobject *a;
mpzobject *b;
cmpres =
#endif /* def MPZ_SPARE_MALLOC */
mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
- err_setstr(ZeroDivisionError, "mpz.% by zero");
+ PyErr_SetString(PyExc_ZeroDivisionError, "mpz.% by zero");
return NULL;
}
#ifdef MPZ_SPARE_MALLOC
if (cmpres > 0) {
- if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)2)) == 0) {
- INCREF(mpz_value_one);
- return (object *)mpz_value_one;
+ if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)2)) == 0)
+ {
+ Py_INCREF(mpz_value_one);
+ return (PyObject *)mpz_value_one;
}
if (cmpres < 0) {
/* b must be 1 now */
- INCREF(mpz_value_zero);
- return (object *)mpz_value_zero;
+ Py_INCREF(mpz_value_zero);
+ return (PyObject *)mpz_value_zero;
}
}
#endif /* def MPZ_SPARE_MALLOC */
mpz_out_str(stderr, 10, &z->mpz);
putc('\n', stderr);
#endif /* def MPZ_TEST_DIV */
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_remainder() */
-static object *
+static PyObject *
mpz_div_and_mod(a, b)
mpzobject *a;
mpzobject *b;
{
- object *z = NULL;
+ PyObject *z = NULL;
mpzobject *x = NULL, *y = NULL;
if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
- err_setstr(ZeroDivisionError, "mpz.divmod by zero");
+ PyErr_SetString(PyExc_ZeroDivisionError, "mpz.divmod by zero");
return NULL;
}
- if ((z = newtupleobject(2)) == NULL
+ if ((z = PyTuple_New(2)) == NULL
|| (x = newmpzobject()) == NULL
|| (y = newmpzobject()) == NULL) {
- XDECREF(z);
- XDECREF(x);
- XDECREF(y);
+ Py_XDECREF(z);
+ Py_XDECREF(x);
+ Py_XDECREF(y);
return NULL;
}
putc('\n', stderr);
#endif /* def MPZ_TEST_DIV */
- (void)settupleitem(z, 0, (object *)x);
- (void)settupleitem(z, 1, (object *)y);
+ (void)PyTuple_SetItem(z, 0, (PyObject *)x);
+ (void)PyTuple_SetItem(z, 1, (PyObject *)y);
return z;
} /* mpz_div_and_mod() */
-static object *
+static PyObject *
mpz_power(a, b, m)
mpzobject *a;
mpzobject *b;
mpzobject *z;
int cmpres;
- if ((object *)m!=Py_None)
- {
- mpzobject *z2;
- INCREF(Py_None);
- z=(mpzobject *)mpz_power(a, b, (mpzobject *)Py_None);
- DECREF(Py_None);
- if (z==NULL) return((object *)z);
- z2=(mpzobject *)mpz_remainder(z, m);
- DECREF(z);
- return((object *)z2);
- }
+ if ((PyObject *)m != Py_None) {
+ mpzobject *z2;
+ Py_INCREF(Py_None);
+ z=(mpzobject *)mpz_power(a, b, (mpzobject *)Py_None);
+ Py_DECREF(Py_None);
+ if (z==NULL) return((PyObject *)z);
+ z2=(mpzobject *)mpz_remainder(z, m);
+ Py_DECREF(z);
+ return((PyObject *)z2);
+ }
if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
/* the gnu-mp lib sets pow(0,0) to 0, we to 1 */
- INCREF(mpz_value_one);
- return (object *)mpz_value_one;
+ Py_INCREF(mpz_value_one);
+ return (PyObject *)mpz_value_one;
}
if (cmpres < 0) {
- err_setstr(ValueError, "mpz.pow to negative exponent");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.pow to negative exponent");
return NULL;
}
if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) {
/* the base is 0 */
- INCREF(mpz_value_zero);
- return (object *)mpz_value_zero;
+ Py_INCREF(mpz_value_zero);
+ return (PyObject *)mpz_value_zero;
}
else if (cmpres > 0
&& mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) {
/* the base is 1 */
- INCREF(mpz_value_one);
- return (object *)mpz_value_one;
+ Py_INCREF(mpz_value_one);
+ return (PyObject *)mpz_value_one;
}
else if (cmpres < 0
&& mpz_cmp_si(&a->mpz, (long int)-1) == 0) {
if (mpz_cmp_ui(&tmpmpz, (unsigned int)0) == 0) {
mpz_clear(&tmpmpz);
- INCREF(mpz_value_one);
- return (object *)mpz_value_one;
+ Py_INCREF(mpz_value_one);
+ return (PyObject *)mpz_value_one;
}
mpz_clear(&tmpmpz);
- INCREF(mpz_value_mone);
- return (object *)mpz_value_mone;
+ Py_INCREF(mpz_value_mone);
+ return (PyObject *)mpz_value_mone;
}
#ifdef MPZ_LIB_DOES_CHECKING
/* check if it's doable: sizeof(exp) > sizeof(long) &&
abs(base) > 1 ?? --> No Way */
if (mpz_size(&b->mpz) > 1)
- return (object *)err_nomem();
+ return (PyObject *)PyErr_NoMemory();
#else /* def MPZ_LIB_DOES_CHECKING */
/* wet finger method */
if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
- err_setstr(ValueError, "mpz.pow outrageous exponent");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.pow outrageous exponent");
return NULL;
}
#endif /* def MPZ_LIB_DOES_CHECKING else */
mpz_pow_ui(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_power() */
-static object *
+static PyObject *
mpz_negative(v)
mpzobject *v;
{
#ifdef MPZ_SPARE_MALLOC
if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) == 0) {
/* -0 == 0 */
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
}
#endif /* def MPZ_SPARE_MALLOC */
return NULL;
mpz_neg(&z->mpz, &v->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_negative() */
-static object *
+static PyObject *
mpz_positive(v)
mpzobject *v;
{
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
} /* mpz_positive() */
-static object *
+static PyObject *
mpz_absolute(v)
mpzobject *v;
{
if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) >= 0) {
- INCREF(v);
- return (object *)v;
+ Py_INCREF(v);
+ return (PyObject *)v;
}
if ((z = newmpzobject()) == NULL)
return NULL;
mpz_neg(&z->mpz, &v->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_absolute() */
static int
return mpz_cmp_ui(&v->mpz, (unsigned long int)0) != 0;
} /* mpz_nonzero() */
-static object *
+static PyObject *
py_mpz_invert(v)
mpzobject *v;
{
return NULL;
mpz_com(&z->mpz, &v->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* py_mpz_invert() */
-static object *
+static PyObject *
mpz_lshift(a, b)
mpzobject *a;
mpzobject *b;
if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
/* a << 0 == a */
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
if (cmpres < 0) {
- err_setstr(ValueError, "mpz.<< negative shift count");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.<< negative shift count");
return NULL;
}
#ifdef MPZ_LIB_DOES_CHECKING
if (mpz_size(&b->mpz) > 1)
- return (object *)err_nomem();
+ return (PyObject *)PyErr_NoMemory();
#else /* def MPZ_LIB_DOES_CHECKING */
/* wet finger method */
if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
- err_setstr(ValueError, "mpz.<< outrageous shift count");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.<< outrageous shift count");
return NULL;
}
#endif /* def MPZ_LIB_DOES_CHECKING else */
return NULL;
mpz_mul_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_lshift() */
-static object *
+static PyObject *
mpz_rshift(a, b)
mpzobject *a;
mpzobject *b;
if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
/* a >> 0 == a */
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
if (cmpres < 0) {
- err_setstr(ValueError, "mpz.>> negative shift count");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.>> negative shift count");
return NULL;
}
if (mpz_size(&b->mpz) > 1)
- return (object *)err_nomem();
+ return (PyObject *)PyErr_NoMemory();
if ((z = newmpzobject()) == NULL)
return NULL;
mpz_div_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_rshift() */
-static object *
+static PyObject *
mpz_andfunc(a, b)
mpzobject *a;
mpzobject *b;
return NULL;
mpz_and(&z->mpz, &a->mpz, &b->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_andfunc() */
/* hack Hack HAck HACk HACK, XXX this code is dead slow */
mpz_clear(&tmpmpz);
} /* mpz_xor() HACK */
-static object *
+static PyObject *
mpz_xorfunc(a, b)
mpzobject *a;
mpzobject *b;
return NULL;
mpz_xor(&z->mpz, &a->mpz, &b->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_xorfunc() */
-static object *
+static PyObject *
mpz_orfunc(a, b)
mpzobject *a;
mpzobject *b;
return NULL;
mpz_ior(&z->mpz, &a->mpz, &b->mpz);
- return (object *)z;
+ return (PyObject *)z;
} /* mpz_orfunc() */
/* MPZ initialisation */
#include "longintrepr.h"
-static object *
+static PyObject *
MPZ_mpz(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
mpzobject *mpzp;
- object *objp;
+ PyObject *objp;
#ifdef MPZ_DEBUG
fputs("MPZ_mpz() called...\n", stderr);
#endif /* def MPZ_DEBUG */
- if (!getargs(args, "O", &objp))
+ if (!PyArg_Parse(args, "O", &objp))
return NULL;
/* at least we know it's some object */
/* note DON't DECREF args NEITHER objp */
- if (is_intobject(objp)) {
+ if (PyInt_Check(objp)) {
long lval;
- if (!getargs(objp, "l", &lval))
+ if (!PyArg_Parse(objp, "l", &lval))
return NULL;
if (lval == (long)0) {
- INCREF(mpz_value_zero);
+ Py_INCREF(mpz_value_zero);
mpzp = mpz_value_zero;
}
else if (lval == (long)1) {
- INCREF(mpz_value_one);
+ Py_INCREF(mpz_value_one);
mpzp = mpz_value_one;
}
else if ((mpzp = newmpzobject()) == NULL)
return NULL;
else mpz_set_si(&mpzp->mpz, lval);
}
- else if (is_longobject(objp)) {
+ else if (PyLong_Check(objp)) {
MP_INT mplongdigit;
int i;
unsigned char isnegative;
mpz_init(&mplongdigit);
/* how we're gonna handle this? */
- if ((isnegative = ((i = ((longobject *)objp)->ob_size) < 0) ))
+ if ((isnegative =
+ ((i = ((PyLongObject *)objp)->ob_size) < 0) ))
i = -i;
while (i--) {
mpz_set_ui(&mplongdigit,
(unsigned long)
- ((longobject *)objp)->ob_digit[i]);
+ ((PyLongObject *)objp)->ob_digit[i]);
mpz_mul_2exp(&mplongdigit,&mplongdigit,
(unsigned long int)i * SHIFT);
mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit);
/* get rid of allocation for tmp variable */
mpz_clear(&mplongdigit);
}
- else if (is_stringobject(objp)) {
+ else if (PyString_Check(objp)) {
char *cp;
int len;
MP_INT mplongdigit;
- if (!getargs(objp, "s#", &cp, &len))
+ if (!PyArg_Parse(objp, "s#", &cp, &len))
return NULL;
if ((mpzp = newmpzobject()) == NULL)
mpz_clear(&mplongdigit);
}
else if (is_mpzobject(objp)) {
- INCREF(objp);
+ Py_INCREF(objp);
mpzp = (mpzobject *)objp;
}
else {
- err_setstr(TypeError,
- "mpz.mpz() expects integer, long, string or mpz object argument");
+ PyErr_SetString(PyExc_TypeError,
+"mpz.mpz() expects integer, long, string or mpz object argument");
return NULL;
}
mpz_out_str(stderr, 10, &mpzp->mpz);
putc('\n', stderr);
#endif /* def MPZ_DEBUG */
- return (object *)mpzp;
+ return (PyObject *)mpzp;
} /* MPZ_mpz() */
static mpzobject *
mpz_mpzcoerce(z)
- object *z;
+ PyObject *z;
{
/* shortcut: 9 out of 10 times the type is already ok */
if (is_mpzobject(z)) {
- INCREF(z);
+ Py_INCREF(z);
return (mpzobject *)z; /* coercion succeeded */
}
/* what types do we accept?: intobjects and longobjects */
- if (is_intobject(z) || is_longobject(z))
- return (mpzobject *)MPZ_mpz((object *)NULL, z);
+ if (PyInt_Check(z) || PyLong_Check(z))
+ return (mpzobject *)MPZ_mpz((PyObject *)NULL, z);
- err_setstr(TypeError, "number coercion (to mpzobject) failed");
+ PyErr_SetString(PyExc_TypeError,
+ "number coercion (to mpzobject) failed");
return NULL;
} /* mpz_mpzcoerce() */
/* Forward */
-static void mpz_divm PROTO((MP_INT *res, const MP_INT *num,
- const MP_INT *den, const MP_INT *mod));
+static void mpz_divm Py_PROTO((MP_INT *res, const MP_INT *num,
+ const MP_INT *den, const MP_INT *mod));
-static object *
+static PyObject *
MPZ_powm(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *base, *exp, *mod;
+ PyObject *base, *exp, *mod;
mpzobject *mpzbase = NULL, *mpzexp = NULL, *mpzmod = NULL;
mpzobject *z;
int tstres;
- if (!getargs(args, "(OOO)", &base, &exp, &mod))
+ if (!PyArg_Parse(args, "(OOO)", &base, &exp, &mod))
return NULL;
if ((mpzbase = mpz_mpzcoerce(base)) == NULL
|| (mpzexp = mpz_mpzcoerce(exp)) == NULL
|| (mpzmod = mpz_mpzcoerce(mod)) == NULL
|| (z = newmpzobject()) == NULL) {
- XDECREF(mpzbase);
- XDECREF(mpzexp);
- XDECREF(mpzmod);
+ Py_XDECREF(mpzbase);
+ Py_XDECREF(mpzexp);
+ Py_XDECREF(mpzmod);
return NULL;
}
if ((tstres=mpz_cmp_ui(&mpzexp->mpz, (unsigned long int)0)) == 0) {
- INCREF(mpz_value_one);
- return (object *)mpz_value_one;
+ Py_INCREF(mpz_value_one);
+ return (PyObject *)mpz_value_one;
}
if (tstres < 0) {
mpz_powm(&z->mpz, &mpzbase->mpz, &mpzexp->mpz, &mpzmod->mpz);
}
- DECREF(mpzbase);
- DECREF(mpzexp);
- DECREF(mpzmod);
+ Py_DECREF(mpzbase);
+ Py_DECREF(mpzexp);
+ Py_DECREF(mpzmod);
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_powm() */
-static object *
+static PyObject *
MPZ_gcd(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *op1, *op2;
+ PyObject *op1, *op2;
mpzobject *mpzop1 = NULL, *mpzop2 = NULL;
mpzobject *z;
- if (!getargs(args, "(OO)", &op1, &op2))
+ if (!PyArg_Parse(args, "(OO)", &op1, &op2))
return NULL;
if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL
|| (mpzop2 = mpz_mpzcoerce(op2)) == NULL
|| (z = newmpzobject()) == NULL) {
- XDECREF(mpzop1);
- XDECREF(mpzop2);
+ Py_XDECREF(mpzop1);
+ Py_XDECREF(mpzop2);
return NULL;
}
/* ok, we have three mpzobjects, and an initialised result holder */
mpz_gcd(&z->mpz, &mpzop1->mpz, &mpzop2->mpz);
- DECREF(mpzop1);
- DECREF(mpzop2);
+ Py_DECREF(mpzop1);
+ Py_DECREF(mpzop2);
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_gcd() */
-static object *
+static PyObject *
MPZ_gcdext(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *op1, *op2, *z = NULL;
+ PyObject *op1, *op2, *z = NULL;
mpzobject *mpzop1 = NULL, *mpzop2 = NULL;
mpzobject *g = NULL, *s = NULL, *t = NULL;
- if (!getargs(args, "(OO)", &op1, &op2))
+ if (!PyArg_Parse(args, "(OO)", &op1, &op2))
return NULL;
if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL
|| (mpzop2 = mpz_mpzcoerce(op2)) == NULL
- || (z = newtupleobject(3)) == NULL
+ || (z = PyTuple_New(3)) == NULL
|| (g = newmpzobject()) == NULL
|| (s = newmpzobject()) == NULL
|| (t = newmpzobject()) == NULL) {
- XDECREF(mpzop1);
- XDECREF(mpzop2);
- XDECREF(z);
- XDECREF(g);
- XDECREF(s);
+ Py_XDECREF(mpzop1);
+ Py_XDECREF(mpzop2);
+ Py_XDECREF(z);
+ Py_XDECREF(g);
+ Py_XDECREF(s);
/*XDECREF(t);*/
return NULL;
}
mpz_gcdext(&g->mpz, &s->mpz, &t->mpz, &mpzop1->mpz, &mpzop2->mpz);
- DECREF(mpzop1);
- DECREF(mpzop2);
+ Py_DECREF(mpzop1);
+ Py_DECREF(mpzop2);
- (void)settupleitem(z, 0, (object *)g);
- (void)settupleitem(z, 1, (object *)s);
- (void)settupleitem(z, 2, (object *)t);
+ (void)PyTuple_SetItem(z, 0, (PyObject *)g);
+ (void)PyTuple_SetItem(z, 1, (PyObject *)s);
+ (void)PyTuple_SetItem(z, 2, (PyObject *)t);
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_gcdext() */
-static object *
+static PyObject *
MPZ_sqrt(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *op;
+ PyObject *op;
mpzobject *mpzop = NULL;
mpzobject *z;
- if (!getargs(args, "O", &op))
+ if (!PyArg_Parse(args, "O", &op))
return NULL;
if ((mpzop = mpz_mpzcoerce(op)) == NULL
|| (z = newmpzobject()) == NULL) {
- XDECREF(mpzop);
+ Py_XDECREF(mpzop);
return NULL;
}
mpz_sqrt(&z->mpz, &mpzop->mpz);
- DECREF(mpzop);
+ Py_DECREF(mpzop);
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_sqrt() */
-static object *
+static PyObject *
MPZ_sqrtrem(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *op, *z = NULL;
+ PyObject *op, *z = NULL;
mpzobject *mpzop = NULL;
mpzobject *root = NULL, *rem = NULL;
- if (!getargs(args, "O", &op))
+ if (!PyArg_Parse(args, "O", &op))
return NULL;
if ((mpzop = mpz_mpzcoerce(op)) == NULL
- || (z = newtupleobject(2)) == NULL
+ || (z = PyTuple_New(2)) == NULL
|| (root = newmpzobject()) == NULL
|| (rem = newmpzobject()) == NULL) {
- XDECREF(mpzop);
- XDECREF(z);
- XDECREF(root);
+ Py_XDECREF(mpzop);
+ Py_XDECREF(z);
+ Py_XDECREF(root);
/*XDECREF(rem);*/
return NULL;
}
mpz_sqrtrem(&root->mpz, &rem->mpz, &mpzop->mpz);
- DECREF(mpzop);
+ Py_DECREF(mpzop);
- (void)settupleitem(z, 0, (object *)root);
- (void)settupleitem(z, 1, (object *)rem);
+ (void)PyTuple_SetItem(z, 0, (PyObject *)root);
+ (void)PyTuple_SetItem(z, 1, (PyObject *)rem);
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_sqrtrem() */
} /* mpz_divm() */
-static object *
+static PyObject *
MPZ_divm(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- object *num, *den, *mod;
+ PyObject *num, *den, *mod;
mpzobject *mpznum, *mpzden, *mpzmod = NULL;
mpzobject *z = NULL;
- if (!getargs(args, "(OOO)", &num, &den, &mod))
+ if (!PyArg_Parse(args, "(OOO)", &num, &den, &mod))
return NULL;
if ((mpznum = mpz_mpzcoerce(num)) == NULL
|| (mpzden = mpz_mpzcoerce(den)) == NULL
|| (mpzmod = mpz_mpzcoerce(mod)) == NULL
|| (z = newmpzobject()) == NULL ) {
- XDECREF(mpznum);
- XDECREF(mpzden);
- XDECREF(mpzmod);
+ Py_XDECREF(mpznum);
+ Py_XDECREF(mpzden);
+ Py_XDECREF(mpzmod);
return NULL;
}
mpz_divm(&z->mpz, &mpznum->mpz, &mpzden->mpz, &mpzmod->mpz);
- DECREF(mpznum);
- DECREF(mpzden);
- DECREF(mpzmod);
+ Py_DECREF(mpznum);
+ Py_DECREF(mpzden);
+ Py_DECREF(mpzmod);
if (mpz_cmp_ui(&z->mpz, (unsigned long int)0) == 0) {
- DECREF(z);
- err_setstr(ValueError, "gcd(den, mod) != 1 or num == 0");
+ Py_DECREF(z);
+ PyErr_SetString(PyExc_ValueError,
+ "gcd(den, mod) != 1 or num == 0");
return NULL;
}
- return (object *)z;
+ return (PyObject *)z;
} /* MPZ_divm() */
/* MPZ methods-as-attributes */
#ifdef MPZ_CONVERSIONS_AS_METHODS
-static object *
+static PyObject *
mpz_int(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
#else /* def MPZ_CONVERSIONS_AS_METHODS */
-static object *
+static PyObject *
mpz_int(self)
mpzobject *self;
#endif /* def MPZ_CONVERSIONS_AS_METHODS else */
#ifdef MPZ_CONVERSIONS_AS_METHODS
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
if (mpz_size(&self->mpz) > 1
|| (sli = (long)mpz_get_ui(&self->mpz)) < (long)0 ) {
- err_setstr(ValueError, "mpz.int() arg too long to convert");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.int() arg too long to convert");
return NULL;
}
if (mpz_cmp_ui(&self->mpz, (unsigned long)0) < 0)
sli = -sli;
- return newintobject(sli);
+ return PyInt_FromLong(sli);
} /* mpz_int() */
-static object *
+static PyObject *
#ifdef MPZ_CONVERSIONS_AS_METHODS
mpz_long(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
#else /* def MPZ_CONVERSIONS_AS_METHODS */
mpz_long(self)
mpzobject *self;
{
int i, isnegative;
unsigned long int uli;
- longobject *longobjp;
+ PyLongObject *longobjp;
int ldcount;
int bitpointer, newbitpointer;
MP_INT mpzscratch;
#ifdef MPZ_CONVERSIONS_AS_METHODS
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
/* determine length of python-long to be allocated */
- if ((longobjp = alloclongobject(i = (int)
+ if ((longobjp = _PyLong_New(i = (int)
((mpz_size(&self->mpz) * BITS_PER_MP_LIMB
+ SHIFT - 1) /
SHIFT))) == NULL)
if (isnegative)
longobjp->ob_size = -longobjp->ob_size;
- return (object *)longobjp;
+ return (PyObject *)longobjp;
} /* mpz_long() */
static const double multiplier = 256.0 * 256.0 * 256.0 * 256.0;
#ifdef MPZ_CONVERSIONS_AS_METHODS
-static object *
+static PyObject *
mpz_float(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
#else /* def MPZ_CONVERSIONS_AS_METHODS */
-static object *
+static PyObject *
mpz_float(self)
mpzobject *self;
#endif /* def MPZ_CONVERSIONS_AS_METHODS else */
#ifdef MPZ_CONVERSIONS_AS_METHODS
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
i = (int)mpz_size(&self->mpz);
/* determine sign, and copy abs(self) to scratch var */
- if ((isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0))) {
+ if ((isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)))
+ {
mpz_init(&mpzscratch);
mpz_neg(&mpzscratch, &self->mpz);
}
if (isnegative)
x = -x;
- return newfloatobject(x);
+ return PyFloat_FromDouble(x);
} /* mpz_float() */
#ifdef MPZ_CONVERSIONS_AS_METHODS
-static object *
+static PyObject *
mpz_hex(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
#else /* def MPZ_CONVERSIONS_AS_METHODS */
-static object *
+static PyObject *
mpz_hex(self)
mpzobject *self;
#endif /* def MPZ_CONVERSIONS_AS_METHODS else */
{
#ifdef MPZ_CONVERSIONS_AS_METHODS
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
} /* mpz_hex() */
#ifdef MPZ_CONVERSIONS_AS_METHODS
-static object *
+static PyObject *
mpz_oct(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
#else /* def MPZ_CONVERSIONS_AS_METHODS */
-static object *
+static PyObject *
mpz_oct(self)
mpzobject *self;
#endif /* def MPZ_CONVERSIONS_AS_METHODS else */
{
#ifdef MPZ_CONVERSIONS_AS_METHODS
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
return mpz_format(self, 8, (unsigned char)1);
} /* mpz_oct() */
-static object *
+static PyObject *
mpz_binary(self, args)
mpzobject *self;
- object *args;
+ PyObject *args;
{
int size;
- stringobject *strobjp;
+ PyStringObject *strobjp;
char *cp;
MP_INT mp;
unsigned long ldigit;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0) {
- err_setstr(ValueError, "mpz.binary() arg must be >= 0");
+ PyErr_SetString(PyExc_ValueError,
+ "mpz.binary() arg must be >= 0");
return NULL;
}
mpz_init_set(&mp, &self->mpz);
size = (int)mpz_size(&mp);
- if ((strobjp = (stringobject *)
- newsizedstringobject((char *)0,
- size * sizeof (unsigned long int))) == NULL)
+ if ((strobjp = (PyStringObject *)
+ PyString_FromStringAndSize(
+ (char *)0, size * sizeof (unsigned long int))) == NULL)
return NULL;
/* get the beginning of the string memory and start copying things */
- cp = GETSTRINGVALUE(strobjp);
+ cp = PyString_AS_STRING(strobjp);
/* this has been programmed using a (fairly) decent lib-i/f it could
be must faster if we looked into the GMP lib */
while (strobjp->ob_size && !*--cp)
strobjp->ob_size--;
- return (object *)strobjp;
+ return (PyObject *)strobjp;
} /* mpz_binary() */
-static struct methodlist mpz_methods[] = {
+static PyMethodDef mpz_methods[] = {
#ifdef MPZ_CONVERSIONS_AS_METHODS
{"int", mpz_int},
{"long", mpz_long},
{"hex", mpz_hex},
{"oct", mpz_oct},
#endif /* def MPZ_CONVERSIONS_AS_METHODS */
- {"binary", (object *(*)(object *, object *))mpz_binary},
+ {"binary", (PyCFunction)mpz_binary},
{NULL, NULL} /* sentinel */
};
-static object *
+static PyObject *
mpz_getattr(self, name)
mpzobject *self;
char *name;
{
- return findmethod(mpz_methods, (object *)self, name);
+ return Py_FindMethod(mpz_methods, (PyObject *)self, name);
} /* mpz_getattr() */
static int
mpz_coerce(pv, pw)
- object **pv;
- object **pw;
+ PyObject **pv;
+ PyObject **pw;
{
- object *z;
+ PyObject *z;
#ifdef MPZ_DEBUG
fputs("mpz_coerce() called...\n", stderr);
assert(is_mpzobject(*pv));
/* always convert other arg to mpz value, except for floats */
- if (!is_floatobject(*pw)) {
- if ((z = (object *)mpz_mpzcoerce(*pw)) == NULL)
+ if (!PyFloat_Check(*pw)) {
+ if ((z = (PyObject *)mpz_mpzcoerce(*pw)) == NULL)
return -1; /* -1: an error always has been set */
- INCREF(*pv);
+ Py_INCREF(*pv);
*pw = z;
}
else {
if ((z = mpz_float(*pv, NULL)) == NULL)
return -1;
- INCREF(*pw);
+ Py_INCREF(*pw);
*pv = z;
}
return 0; /* coercion succeeded */
} /* mpz_coerce() */
-static object *
+static PyObject *
mpz_repr(v)
- object *v;
+ PyObject *v;
{
return mpz_format(v, 10, (unsigned char)1);
} /* mpz_repr() */
#define IF (inquiry)
#define CF (coercion)
-static number_methods mpz_as_number = {
+static PyNumberMethods mpz_as_number = {
BF mpz_addition, /*nb_add*/
BF mpz_substract, /*nb_subtract*/
BF mpz_multiply, /*nb_multiply*/
#endif /* ndef MPZ_CONVERSIONS_AS_METHODS */
};
-static typeobject MPZtype = {
- OB_HEAD_INIT(&Typetype)
+static PyTypeObject MPZtype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"mpz", /*tp_name*/
sizeof(mpzobject), /*tp_size*/
/* List of functions exported by this module */
-static struct methodlist mpz_functions[] = {
+static PyMethodDef mpz_functions[] = {
#if 0
{initialiser_name, MPZ_mpz},
#else /* 0 */
/* assumptions: *alloc returns address dividable by 4,
mpz_* routines allocate in chunks dividable by four */
fprintf(stderr, "MP_TEST_ERROR: location holds 0x%08d\n", *location );
- fatal("MP_TEST_ERROR");
+ Py_FatalError("MP_TEST_ERROR");
} /* static mp_test_error() */
#define MP_EXTRA_ALLOC(size) ((size) + MP_TEST_SIZE)
#define MP_SET_TEST(basep,size) (void)memcpy( ((char *)(basep))+(size), mp_test_magic, MP_TEST_SIZE)
#endif /* def MPZ_DEBUG */
if ( (res = malloc(MP_EXTRA_ALLOC(alloc_size))) == NULL )
- fatal("mp_allocate failure");
+ Py_FatalError("mp_allocate failure");
#ifdef MPZ_DEBUG
fprintf(stderr, "mp_allocate : address 0x%08x\n", res);
MP_DO_TEST(ptr, old_size);
if ( (res = realloc(ptr, MP_EXTRA_ALLOC(new_size))) == NULL )
- fatal("mp_reallocate failure");
+ Py_FatalError("mp_reallocate failure");
#ifdef MPZ_DEBUG
fprintf(stderr, "mp_reallocate: new address 0x%08x, new size %ld\n",
#endif /* def MPZ_DEBUG */
mp_set_memory_functions( mp_allocate, mp_reallocate, mp_free );
- (void)initmodule("mpz", mpz_functions);
+ (void)Py_InitModule("mpz", mpz_functions);
/* create some frequently used constants */
if ((mpz_value_zero = newmpzobject()) == NULL)
- fatal("initmpz: can't initialize mpz constants");
+ Py_FatalError("initmpz: can't initialize mpz constants");
mpz_set_ui(&mpz_value_zero->mpz, (unsigned long int)0);
if ((mpz_value_one = newmpzobject()) == NULL)
- fatal("initmpz: can't initialize mpz constants");
+ Py_FatalError("initmpz: can't initialize mpz constants");
mpz_set_ui(&mpz_value_one->mpz, (unsigned long int)1);
if ((mpz_value_mone = newmpzobject()) == NULL)
- fatal("initmpz: can't initialize mpz constants");
+ Py_FatalError("initmpz: can't initialize mpz constants");
mpz_set_si(&mpz_value_mone->mpz, (long)-1);
} /* initmpz() */
projects / python / commitdiff