mp *x;
mpw *p;
- sz = l->ob_size;
+ sz = Py_SIZE(l);
if (sz < 0) sz = -sz;
assert(MPW_BITS >= SHIFT);
bits = (unsigned long)sz * SHIFT;
w = (bits + MPW_BITS - 1)/MPW_BITS;
- x = mp_new(w, l->ob_size < 0 ? MP_NEG : 0);
+ x = mp_new(w, Py_SIZE(l) < 0 ? MP_NEG : 0);
p = x->v;
for (i = 0; i < sz; i++) {
r |= (mpd)l->ob_digit[i] << b;
l->ob_digit[i++] = r & MASK;
r >>= SHIFT;
}
- l->ob_size = (x->f & MP_NEG) ? -sz : sz;
+ Py_SIZE(l) = (x->f & MP_NEG) ? -sz : sz;
return ((PyObject *)l);
}
if (!o) return (0);
if ((x = tomp(o)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to mp",
- o->ob_type->tp_name);
+ Py_TYPE(o)->tp_name);
}
return (x);
}
if (!o) return (0);
if ((x = tomp(o)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to gf",
- o->ob_type->tp_name);
+ Py_TYPE(o)->tp_name);
}
return (x);
}
if (!good_radix_p(radix, 1)) VALERR("bad radix");
if ((z = mp_frompyobject(x, radix)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to mp",
- x->ob_type->tp_name);
+ Py_TYPE(x)->tp_name);
goto end;
}
zz = (mp_pyobj *)ty->tp_alloc(ty, 0);
return (getbool(mp_testbit(MP_X(me), i)));
}
-static PyObject *mpmeth_odd(PyObject *me, PyObject *arg)
+static PyObject *mpmeth_odd(PyObject *me)
{
mp *t;
size_t s;
- if (!PyArg_ParseTuple(arg, ":odd")) return (0);
t = mp_odd(MP_NEW, MP_X(me), &s);
return (Py_BuildValue("(lN)", (long)s, mp_pywrap(t)));
}
-static PyObject *mpmeth_sqr(PyObject *me, PyObject *arg)
-{
- if (!PyArg_ParseTuple(arg, ":sqr")) return (0);
- return (mp_pywrap(mp_sqr(MP_NEW, MP_X(me))));
-}
+static PyObject *mpmeth_sqr(PyObject *me)
+ { return (mp_pywrap(mp_sqr(MP_NEW, MP_X(me)))); }
-static PyObject *mpmeth_sqrt(PyObject *me, PyObject *arg)
+static PyObject *mpmeth_sqrt(PyObject *me)
{
- if (!PyArg_ParseTuple(arg, ":sqrt")) return (0);
if (MP_NEGP(MP_X(me))) VALERR("negative root");
return (mp_pywrap(mp_sqrt(MP_NEW, MP_X(me))));
end:
BUFOP(gf)
#undef BUFOP
-static PyObject *mpmeth_tobuf(PyObject *me, PyObject *arg)
+static PyObject *mpmeth_tobuf(PyObject *me)
{
buf b;
PyObject *rc;
mp *x;
size_t n;
- if (!PyArg_ParseTuple(arg, ":tobuf")) return (0);
x = MP_X(me);
n = mp_octets(x) + 3;
rc = bytestring_pywrap(0, n);
METH (setbit, "X.setbit(N) -> X with bit N set")
METH (clearbit, "X.clearbit(N) -> X with bit N clear")
METH (testbit, "X.testbit(N) -> true/false if bit N set/clear in X")
- METH (odd, "X.odd() -> S, T where X = 2^S T with T odd")
- METH (sqr, "X.sqr() -> X^2")
- METH (sqrt, "X.sqrt() -> largest integer <= sqrt(X)")
+ NAMETH(odd, "X.odd() -> S, T where X = 2^S T with T odd")
+ NAMETH(sqr, "X.sqr() -> X^2")
+ NAMETH(sqrt, "X.sqrt() -> largest integer <= sqrt(X)")
METH (gcd, "X.gcd(Y) -> gcd(X, Y)")
METH (gcdx, "X.gcdx(Y) -> (gcd(X, Y), U, V) "
"with X U + Y V = gcd(X, Y)")
"little-endian bytes, two's complement")
KWMETH(storeb2c, "X.storeb2c([len = -1]) -> "
"big-endian bytes, two's complement")
- METH (tobuf, "X.tobuf() -> buffer format")
+ NAMETH(tobuf, "X.tobuf() -> buffer format")
KWSMTH(fromstring, "fromstring(STR, [radix = 0]) -> (X, REST)\n"
" Parse STR as a large integer, according to RADIX. If RADIX is\n"
" zero, read a prefix from STR to decide radix: allow `0b' for binary,\n"
0, /* @nb_inplace_true_divide@ */
};
-static PyTypeObject mp_pytype_skel = {
+static const PyTypeObject mp_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MP", /* @tp_name@ */
sizeof(mp_pyobj), /* @tp_basicsize@ */
/*----- Products of small integers ----------------------------------------*/
+static PyTypeObject *mpmul_pytype;
+
typedef struct mpmul_pyobj {
PyObject_HEAD
int livep;
return (0);
}
-static PyObject *mmmeth_done(PyObject *me, PyObject *arg)
+static PyObject *mmmeth_done(PyObject *me)
{
mp *x;
- if (!PyArg_ParseTuple(arg, ":done")) goto end;
if (!MPMUL_LIVEP(me)) VALERR("MPMul object invalid");
x = mpmul_done(MPMUL_PY(me));
MPMUL_LIVEP(me) = 0;
static const PyMethodDef mpmul_pymethods[] = {
#define METHNAME(name) mmmeth_##name
METH (factor, "MM.factor(ITERABLE) or MM.factor(I, ...)")
- METH (done, "MM.done() -> PRODUCT")
+ NAMETH(done, "MM.done() -> PRODUCT")
#undef METHNAME
{ 0 }
};
-static PyTypeObject *mpmul_pytype, mpmul_pytype_skel = {
+static const PyTypeObject mpmul_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MPMul", /* @tp_name@ */
sizeof(mpmul_pyobj), /* @tp_basicsize@ */
/*----- Montgomery reduction ----------------------------------------------*/
+static PyTypeObject *mpmont_pytype;
+
typedef struct mpmont_pyobj {
PyObject_HEAD
mpmont mm;
{ 0 }
};
-static PyTypeObject *mpmont_pytype, mpmont_pytype_skel = {
+static const PyTypeObject mpmont_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MPMont", /* @tp_name@ */
sizeof(mpmont_pyobj), /* @tp_basicsize@ */
/*----- Barrett reduction -------------------------------------------------*/
+static PyTypeObject *mpbarrett_pytype;
+
typedef struct mpbarrett_pyobj {
PyObject_HEAD
mpbarrett mb;
{ 0 }
};
-static PyTypeObject *mpbarrett_pytype, mpbarrett_pytype_skel = {
+static const PyTypeObject mpbarrett_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MPBarrett", /* @tp_name@ */
sizeof(mpbarrett_pyobj), /* @tp_basicsize@ */
/*----- Nice prime reduction ----------------------------------------------*/
+static PyTypeObject *mpreduce_pytype;
+
typedef struct mpreduce_pyobj {
PyObject_HEAD
mpreduce mr;
{ 0 }
};
-static PyTypeObject *mpreduce_pytype, mpreduce_pytype_skel = {
+static const PyTypeObject mpreduce_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MPReduce", /* @tp_name@ */
sizeof(mpreduce_pyobj), /* @tp_basicsize@ */
/*----- Chinese Remainder Theorem solution --------------------------------*/
+static PyTypeObject *mpcrt_pytype;
+
typedef struct mpcrt_pyobj {
PyObject_HEAD
mpcrt c;
{ 0 }
};
-static PyTypeObject *mpcrt_pytype, mpcrt_pytype_skel = {
+static const PyTypeObject mpcrt_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"MPCRT", /* @tp_name@ */
sizeof(mpcrt_pyobj), /* @tp_basicsize@ */
if (!good_radix_p(radix, 1)) VALERR("radix out of range");
if ((z = mp_frompyobject(x, radix)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to gf",
- x->ob_type->tp_name);
+ Py_TYPE(x)->tp_name);
goto end;
}
if (MP_NEGP(z)) {
return (rc);
}
-static PyObject *gfmeth_sqr(PyObject *me, PyObject *arg)
-{
- if (!PyArg_ParseTuple(arg, ":sqr")) return (0);
- return (gf_pywrap(gf_sqr(MP_NEW, MP_X(me))));
-}
+static PyObject *gfmeth_sqr(PyObject *me)
+ { return (gf_pywrap(gf_sqr(MP_NEW, MP_X(me)))); }
static PyObject *gfmeth_gcd(PyObject *me, PyObject *arg)
{
return (z);
}
-static PyObject *gfmeth_irreduciblep(PyObject *me, PyObject *arg)
-{
- if (!PyArg_ParseTuple(arg, ":irreduciblep")) return (0);
- return getbool(gf_irreduciblep(MP_X(me)));
-}
+static PyObject *gfmeth_irreduciblep(PyObject *me)
+ { return getbool(gf_irreduciblep(MP_X(me))); }
static PyObject *gfget_degree(PyObject *me, void *hunoz)
{ return (PyInt_FromLong(mp_bits(MP_X(me)) - 1)); }
METH (setbit, "X.setbit(N) -> X with bit N set")
METH (clearbit, "X.clearbit(N) -> X with bit N clear")
METH (testbit, "X.testbit(N) -> true/false if bit N set/clear in X")
- METH (sqr, "X.sqr() -> X^2")
+ NAMETH(sqr, "X.sqr() -> X^2")
METH (gcd, "X.gcd(Y) -> gcd(X, Y)")
METH (gcdx, "X.gcdx(Y) -> (gcd(X, Y), U, V) with X U + Y V = gcd(X, Y)")
METH (modinv, "X.modinv(Y) -> multiplicative inverse of Y mod X")
- METH (irreduciblep, "X.irreduciblep() -> true/false")
+ NAMETH(irreduciblep, "X.irreduciblep() -> true/false")
KWSMTH(fromstring, "fromstring(STR, [radix = 0]) -> (X, REST)\n"
" Parse STR as a binary polynomial, according to RADIX. If RADIX is\n"
" zero, read a prefix from STR to decide radix: allow `0b' for binary,\n"
"little-endian bytes, two's complement")
KWMETH(storeb2c, "X.storeb2c([len = -1]) -> "
"big-endian bytes, two's complement")
- METH (tobuf, "X.tobuf() -> buffer format")
+ NAMETH(tobuf, "X.tobuf() -> buffer format")
#undef METHNAME
{ 0 }
};
0, /* @nb_inplace_true_divide@ */
};
-static PyTypeObject gf_pytype_skel = {
+static const PyTypeObject gf_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"GF", /* @tp_name@ */
sizeof(mp_pyobj), /* @tp_basicsize@ */
/*----- Sparse poly reduction ---------------------------------------------*/
+static PyTypeObject *gfreduce_pytype;
+
typedef struct gfreduce_pyobj {
PyObject_HEAD
gfreduce mr;
{ 0 }
};
-static PyTypeObject *gfreduce_pytype, gfreduce_pytype_skel = {
+static const PyTypeObject gfreduce_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"GFReduce", /* @tp_name@ */
sizeof(gfreduce_pyobj), /* @tp_basicsize@ */
/*----- Normal/poly transformation ----------------------------------------*/
+static PyTypeObject *gfn_pytype;
+
typedef struct gfn_pyobj {
PyObject_HEAD
mp *p;
gfn ntop, pton;
} gfn_pyobj;
-static PyTypeObject *gfn_pytype, gfn_pytype_skel;
-
#define GFN_P(o) (((gfn_pyobj *)(o))->p)
#define GFN_PTON(o) (&((gfn_pyobj *)(o))->pton)
#define GFN_NTOP(o) (&((gfn_pyobj *)(o))->ntop)
{ 0 }
};
-static PyTypeObject gfn_pytype_skel = {
+static const PyTypeObject gfn_pytype_skel = {
PyObject_HEAD_INIT(0) 0, /* Header */
"GFN", /* @tp_name@ */
sizeof(gfn_pyobj), /* @tp_basicsize@ */
/*----- Glue --------------------------------------------------------------*/
+static const struct nameval consts[] = {
+ CONST(MPW_MAX),
+ { 0 }
+};
+
void mp_pyinit(void)
{
INITTYPE(mp, root);
INSERT("GF", gf_pytype);
INSERT("GFReduce", gfreduce_pytype);
INSERT("GFN", gfn_pytype);
+ setconstants(mod, consts);
}
/*----- That's all, folks -------------------------------------------------*/