mp *x;
size_t sz;
TEXT_PTRLEN(o, sc.buf, sz); sc.lim = sc.buf + sz;
+ if (sc.buf + 2 < sc.lim && sc.buf[0] == '0' &&
+ (radix == 16 ? (sc.buf[1] == 'x' || sc.buf[1] == 'X') :
+ radix == 8 ? (sc.buf[1] == 'o' || sc.buf[1] == 'O') :
+ radix == 2 ? (sc.buf[1] == 'b' || sc.buf[1] == 'B') :
+ 0))
+ sc.buf += 2;
x = mp_read(MP_NEW, radix, &mptext_stringops, &sc);
if (!x) return (0);
if (sc.buf < sc.lim) { MP_DROP(x); return (0); }
return (rc);
}
-/*----- Python interface --------------------------------------------------*/
+/*----- Arbitrary-precision integers --------------------------------------*/
static void mp_pydealloc(PyObject *o)
{
mp *implicitmp(PyObject *o)
{
- if (!o ||
- GF_PYCHECK(o) ||
- ECPT_PYCHECK(o) ||
- FE_PYCHECK(o) ||
- GE_PYCHECK(o))
- return (0);
- return (tomp(o));
+ PyObject *l;
+
+ if (!o || GF_PYCHECK(o) || FE_PYCHECK(o)) return (0);
+ else if (MP_PYCHECK(o)) return (MP_COPY(MP_X(o)));
+ else if (PFILT_PYCHECK(o)) return (MP_COPY(PFILT_F(o)->m));
+#ifdef PY2
+ else if (PyInt_Check(o)) return (mp_fromlong(MP_NEW, PyInt_AS_LONG(o)));
+#endif
+ else if ((l = PyNumber_Index(o)) != 0) {
+#ifdef PY2
+ if (PyInt_Check(o)) return (mp_fromlong(MP_NEW, PyInt_AS_LONG(o)));
+#endif
+ if (PyLong_Check(o)) return (mp_frompylong(o));
+ }
+ PyErr_Clear(); return (0);
}
mp *implicitgf(PyObject *o)
{
- if (!o ||
- MP_PYCHECK(o) ||
- ECPT_PYCHECK(o) ||
- FE_PYCHECK(o) ||
- GE_PYCHECK(o))
- return (0);
- return (tomp(o));
+ if (GF_PYCHECK(o)) return (MP_COPY(MP_X(o)));
+ return (0);
}
static int mpbinop(PyObject *x, PyObject *y, mp **xx, mp **yy)
return ((PyObject *)zz);
}
+#define IMPLICIT(pre) \
+ static PyObject *pre##meth__implicit(PyObject *me, PyObject *arg) \
+ { \
+ PyObject *x, *rc = 0; \
+ mp *y = MP_NEW; \
+ if (!PyArg_ParseTuple(arg, "O:_implicit", &x)) goto end; \
+ y = implicit##pre(x); \
+ if (!y) TYERR("can't convert implicitly to " #pre); \
+ rc = pre##_pywrap(y); \
+ end: \
+ return (rc); \
+ }
+IMPLICIT(mp)
+IMPLICIT(gf)
+#undef IMPLICIT
+
Py_hash_t mphash(mp *x)
{
PyObject *l = mp_topylong(x);
" 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' or `0o' for octal, `0x' for hex, or `R_' for other radix R.")
+ SMTH (_implicit, 0)
SMTH (factorial, "factorial(I) -> I!: compute factorial")
SMTH (fibonacci, "fibonacci(I) -> F(I): compute Fibonacci number")
SMTH (loadl, "loadl(STR) -> X: read little-endian bytes")
return (-1);
}
-static PyObject *mm_mexpr(PyObject *me, void *v, int n)
+static PyObject *mm_mexpr(PyObject *me, void *v, size_t n)
{ return mp_pywrap(mpmont_mexpr(MPMONT_PY(me), MP_NEW, v, n)); }
static void mp_mexp_drop(void *p)
return (-1);
}
-static PyObject *mm_mexp(PyObject *me, void *v, int n)
+static PyObject *mm_mexp(PyObject *me, void *v, size_t n)
{ return mp_pywrap(mpmont_mexp(MPMONT_PY(me), MP_NEW, v, n)); }
static PyObject *mmmeth_mexp(PyObject *me, PyObject *arg)
return (rc);
}
-static PyObject *mb_mexp(PyObject *me, void *v, int n)
+static PyObject *mb_mexp(PyObject *me, void *v, size_t n)
{ return mp_pywrap(mpbarrett_mexp(MPBARRETT_PY(me), MP_NEW, v, n)); }
static PyObject *mbmeth_mexp(PyObject *me, PyObject *arg)
static PyObject *mcmeth_solve(PyObject *me, PyObject *arg)
{
mpcrt *c = MPCRT_PY(me);
- PyObject *q = 0, *x, *z = 0;
+ PyObject *q = 0, *it, *x, *z = 0;
mp *xx;
mp **v = 0;
Py_ssize_t i = 0, n = c->k;
- Py_INCREF(me);
if (PyTuple_GET_SIZE(arg) == n)
q = arg;
else if (!PyArg_ParseTuple(arg, "O:solve", &q))
goto end;
- Py_INCREF(q);
- if (!PySequence_Check(q)) TYERR("want a sequence of residues");
- i = PySequence_Size(q); if (i < 0) goto end;
- if (i != n) VALERR("residue count mismatch");
- v = xmalloc(n * sizeof(*v));
- for (i = 0; i < n; i++) {
- if ((x = PySequence_GetItem(q, i)) == 0) goto end;
+ v = xmalloc(n*sizeof(*v));
+ it = PyObject_GetIter(q); if (!it) goto end;
+ while (i < n) {
+ x = PyIter_Next(it);
+ if (!x) {
+ if (PyErr_Occurred()) goto end;
+ VALERR("residue count mismatch");
+ }
xx = getmp(x); Py_DECREF(x); if (!xx) goto end;
- v[i] = xx;
+ v[i++] = xx; xx = 0;
}
+ x = PyIter_Next(it);
+ if (x) { Py_DECREF(x); VALERR("residue count mismatch"); }
+ else if (PyErr_Occurred()) goto end;
z = mp_pywrap(mpcrt_solve(c, MP_NEW, v));
end:
if (v) {
- n = i;
- for (i = 0; i < n; i++)
- MP_DROP(v[i]);
+ while (i--) MP_DROP(v[i]);
xfree(v);
}
- Py_DECREF(me);
- Py_XDECREF(q);
return (z);
}
mpcrt_mod *v = 0;
Py_ssize_t n, i = 0, j;
static const char *const kwlist[] = { "mv", 0 };
- PyObject *q = 0, *x;
+ PyObject *q, *it = 0, *x;
mp *xx = MP_NEW, *y = MP_NEW, *g = MP_NEW;
mpmul mm;
mpcrt_pyobj *c = 0;
q = arg;
else if (!PyArg_ParseTupleAndKeywords(arg, kw, "O:new", KWLIST, &q))
goto end;
- Py_INCREF(q);
- if (!PySequence_Check(q)) TYERR("want a sequence of moduli");
- n = PySequence_Size(q); if (n < 0) goto end;
- if (!n) VALERR("want at least one modulus");
- v = xmalloc(n * sizeof(*v));
- for (i = 0; i < n; i++) {
- if ((x = PySequence_GetItem(q, i)) == 0) goto end;
+
+ if (!PySequence_Check(q))
+ n = 16;
+ else {
+ n = PySequence_Size(arg);
+ if (n == (size_t)-1 && PyErr_Occurred()) goto end;
+ }
+
+ v = xmalloc(n*sizeof(*v));
+ it = PyObject_GetIter(q); if (!it) goto end;
+ for (;;) {
+ x = PyIter_Next(it); if (!x) break;
xx = getmp(x); Py_DECREF(x); if (!xx) goto end;
if (MP_CMP(xx, <=, MP_ZERO)) VALERR("moduli must be positive");
- v[i].m = xx; v[i].n = 0; v[i].ni = 0; v[i].nni = 0; xx = MP_NEW;
+ if (i >= n) { n *= 2; v = xrealloc(v, n*sizeof(*v), i*sizeof(*v)); }
+ v[i].m = xx; v[i].n = 0; v[i].ni = 0; v[i].nni = 0; i++; xx = MP_NEW;
}
+ if (PyErr_Occurred()) goto end;
+ Py_DECREF(it); it = 0;
+
mpmul_init(&mm);
for (j = 0; j < i; j++) mpmul_add(&mm, v[j].m);
xx = mpmul_done(&mm);
}
c = (mpcrt_pyobj *)ty->tp_alloc(ty, 0);
- mpcrt_create(&c->c, v, n, 0);
- Py_DECREF(q);
+ mpcrt_create(&c->c, v, i, 0);
mp_drop(xx); mp_drop(y); mp_drop(g);
return ((PyObject *)c);
end:
if (v) {
- n = i;
- for (i = 0; i < n; i++)
- MP_DROP(v[i].m);
+ while (i--) MP_DROP(v[i].m);
xfree(v);
}
- Py_XDECREF(q);
mp_drop(xx); mp_drop(y); mp_drop(g);
+ Py_XDECREF(it);
return (0);
}
" 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"
" `0' or `0o' for octal, `0x' for hex, or `R_' for other radix R.")
+ SMTH (_implicit, 0)
SMTH (loadl, "loadl(STR) -> X: read little-endian bytes")
SMTH (loadb, "loadb(STR) -> X: read big-endian bytes")
SMTH (frombuf, "frombuf(STR) -> (X, REST): read buffer format")
~mdw / catacomb-python / blobdiff