return (0);
a = F_OUT(f, MP_NEW, c->a);
b = F_OUT(f, MP_NEW, c->b);
- if (strcmp(EC_NAME(c), "prime") == 0)
+ if (STRCMP(EC_NAME(c), ==, "prime"))
c = ec_prime(f, a, b);
- else if (strcmp(EC_NAME(c), "primeproj") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "primeproj"))
c = ec_primeproj(f, a, b);
- else if (strcmp(EC_NAME(c), "bin") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "bin"))
c = ec_bin(f, a, b);
- else if (strcmp(EC_NAME(c), "binproj") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "binproj"))
c = ec_binproj(f, a, b);
else
c = 0;
return (rc);
}
-static PyObject *epmeth_oncurvep(PyObject *me, PyObject *arg)
+static PyObject *epmeth_oncurvep(PyObject *me)
{
- if (!PyArg_ParseTuple(arg, ":oncurvep")) return (0);
return (getbool(EC_ATINF(ECPT_P(me)) ||
!EC_CHECK(ECPT_C(me), ECPT_P(me))));
}
-static PyObject *epmeth_dbl(PyObject *me, PyObject *arg)
+static PyObject *epmeth_dbl(PyObject *me)
{
ec p = EC_INIT;
- if (!PyArg_ParseTuple(arg, ":dbl")) return (0);
EC_DBL(ECPT_C(me), &p, ECPT_P(me));
return (ecpt_pywrap(ECPT_COBJ(me), &p));
}
-static PyObject *epmeth_tobuf(PyObject *me, PyObject *arg)
+static PyObject *epmeth_tobuf(PyObject *me)
{
buf b;
ec p = EC_INIT;
PyObject *rc;
size_t n;
- if (!PyArg_ParseTuple(arg, ":tobuf")) return (0);
getecptout(&p, me);
if (EC_ATINF(&p))
n = 2;
else
- n = mp_octets(p.x) + mp_octets(p.y) + 4;
+ n = mp_octets(p.x) + mp_octets(p.y) + 6;
rc = bytestring_pywrap(0, n);
buf_init(&b, PyString_AS_STRING(rc), n);
buf_putec(&b, &p);
return (rc);
}
-static PyObject *epmeth_toraw(PyObject *me, PyObject *arg)
+static PyObject *epmeth_toraw(PyObject *me)
{
buf b;
PyObject *rc;
ec pp = EC_INIT;
int len;
- if (!PyArg_ParseTuple(arg, ":toraw")) return (0);
len = c->f->noctets * 2 + 1;
rc = bytestring_pywrap(0, len);
p = PyString_AS_STRING(rc);
ec pp = EC_INIT;
unsigned f = EC_EXPLY;
int len;
- char *kwlist[] = { "flags", 0 };
+ static const char *const kwlist[] = { "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:ec2osp", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:ec2osp", KWLIST,
convuint, &f))
return (0);
len = c->f->noctets * 2 + 1;
static PyObject *epget_curve(PyObject *me, void *hunoz)
{ RETURN_OBJ(ECPT_COBJ(me)); }
+static PyObject *epmeth_frombuf(PyObject *me, PyObject *arg)
+{
+ buf b;
+ char *p;
+ Py_ssize_t sz;
+ PyObject *rc = 0;
+ ec pp = EC_INIT;
+
+ if (!PyArg_ParseTuple(arg, "s#:frombuf", &p, &sz)) goto end;
+ buf_init(&b, p, sz);
+ if (buf_getec(&b, &pp)) VALERR("malformed data");
+ rc = Py_BuildValue("(NN)", ecpt_pywrapout(me, &pp),
+ bytestring_pywrapbuf(&b));
+end:
+ return (rc);
+}
+
+static PyObject *epmeth_parse(PyObject *me, PyObject *arg)
+{
+ char *p;
+ qd_parse qd;
+ PyObject *rc = 0;
+ ec pp = EC_INIT;
+
+ if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
+ qd.p = p; qd.e = 0;
+ if (!ec_ptparse(&qd, &pp)) VALERR(qd.e);
+ rc = Py_BuildValue("(Ns)", ecpt_pywrapout(me, &pp), qd.p);
+end:
+ return (rc);
+}
+
+static PyObject *epmeth_fromraw(PyObject *me, PyObject *arg)
+{
+ char *p;
+ Py_ssize_t len;
+ buf b;
+ PyObject *rc = 0;
+ ec_curve *cc;
+ ec pp = EC_INIT;
+
+ if (!PyArg_ParseTuple(arg, "s#:fromraw", &me, &p, &len)) return (0);
+ buf_init(&b, p, len);
+ cc = ECCURVE_C(me);
+ if (ec_getraw(cc, &b, &pp))
+ VALERR("bad point");
+ EC_IN(cc, &pp, &pp);
+ rc = Py_BuildValue("(NN)", ecpt_pywrap(me, &pp), bytestring_pywrapbuf(&b));
+end:
+ return (rc);
+}
+
+static PyObject *epmeth_os2ecp(PyObject *me, PyObject *arg, PyObject *kw)
+{
+ char *p;
+ Py_ssize_t len;
+ buf b;
+ PyObject *rc = 0;
+ ec_curve *cc;
+ unsigned f = EC_XONLY | EC_LSB | EC_SORT | EC_EXPLY;
+ ec pp = EC_INIT;
+ static const char *const kwlist[] = { "buf", "flags", 0 };
+
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:os2ecp", KWLIST,
+ &p, &len, convuint, &f))
+ return (0);
+ buf_init(&b, p, len);
+ cc = ECCURVE_C(me);
+ if (ec_os2ecp(cc, f, &b, &pp)) VALERR("bad point");
+ EC_IN(cc, &pp, &pp);
+ rc = Py_BuildValue("(NN)", ecpt_pywrap(me, &pp), bytestring_pywrapbuf(&b));
+end:
+ return (rc);
+}
+
static PyObject *epncget_ix(PyObject *me, void *hunoz)
{
ec p = EC_INIT;
getecptout(p, x);
goto fix;
} else if (PyString_Check(x)) {
- if (PyObject_AsReadBuffer(x, &q, 0))
+ if (PyObject_AsReadBuffer(x, &q, &n))
goto end;
qd.p = q;
qd.e = 0;
if (!EC_FIND(c, p, xx)) VALERR("not on the curve");
} else if (PySequence_Check(x)) {
t = x; x = 0;
- n = PySequence_Size(t);
+ n = PySequence_Size(t); if (n < 0) goto end;
if (n != 2 && (n != 3 || !c))
TYERR("want sequence of two or three items");
if ((x = PySequence_GetItem(t, 0)) == 0 ||
(n == 3 && (z = PySequence_GetItem(t, 2)) == 0))
goto end;
rc = (n == 2) ? ecptxl_2(c, p, x, y) : ecptxl_3(c, p, x, y, z);
+ goto end;
} else
TYERR("can't convert to curve point");
goto ok;
{
PyObject *x = 0, *y = 0, *z = 0;
ec p = EC_INIT;
- char *kwlist[] = { "x", "y", 0 };
+ static const char *const kwlist[] = { "x", "y", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|OO:new", kwlist, &x, &y) ||
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|OO:new", KWLIST, &x, &y) ||
ecptxl(0, &p, x, y, z))
goto end;
return (ecpt_pywrapout(ty, &p));
end:
- EC_DESTROY(&p);
+ mp_drop(p.x); mp_drop(p.y); mp_drop(p.z);
return (0);
}
{
PyObject *x = 0, *y = 0, *z = 0;
ec p = EC_INIT;
- char *kwlist[] = { "x", "y", "z", 0 };
+ static const char *const kwlist[] = { "x", "y", "z", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|OOO:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|OOO:new", KWLIST,
&x, &y, &z) ||
ecptxl(ECCURVE_C(ty), &p, x, y, z))
goto end;
return (ecpt_pywrap((PyObject *)ty, &p));
end:
- EC_DESTROY(&p);
+ mp_drop(p.x); mp_drop(p.y); mp_drop(p.z);
return (0);
}
-static PyGetSetDef ecptnc_pygetset[] = {
+static const PyGetSetDef ecptnc_pygetset[] = {
#define GETSETNAME(op, name) epnc##op##_##name
GET (ix, "P.ix -> integer x coordinate of P")
GET (iy, "P.iy -> integer y coordinate of P")
{ 0 }
};
-static PyMethodDef ecptnc_pymethods[] = {
+static const PyMethodDef ecptnc_pymethods[] = {
#define METHNAME(func) epmeth_##func
- METH (tobuf, "X.tobuf() -> BIN")
+ NAMETH(tobuf, "X.tobuf() -> BIN")
+ CMTH (frombuf, "frombuf(STR) -> (P, REST)")
+ CMTH (parse, "parse(STR) -> (P, REST)")
#undef METHNAME
{ 0 }
};
-static PyNumberMethods ecpt_pynumber = {
+static const PyNumberMethods ecpt_pynumber = {
0, /* @nb_add@ */
0, /* @nb_subtract@ */
0, /* @nb_multiply@ */
0, /* @tp_setattr@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
- &ecpt_pynumber, /* @tp_as_number@ */
+ PYNUMBER(ecpt), /* @tp_as_number@ */
0, /* @tp_as_sequence@ */
0, /* @tp_as_mapping@ */
ecpt_pyhash, /* @tp_hash@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Elliptic curve points, not associated with any curve.",
+ "ECPt([X, [Y]]): elliptic curve points, not associated with any curve.\n"
+ " X alone may be None, an existing point, a string 'X, Y', an\n"
+ " x-coordinate, or a pair (X, Y); X and Y should be a coordinate pair.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- ecptnc_pymethods, /* @tp_methods@ */
+ PYMETHODS(ecptnc), /* @tp_methods@ */
0, /* @tp_members@ */
- ecptnc_pygetset, /* @tp_getset@ */
+ PYGETSET(ecptnc), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
0 /* @tp_is_gc@ */
};
-static PyGetSetDef ecpt_pygetset[] = {
+static const PyGetSetDef ecpt_pygetset[] = {
#define GETSETNAME(op, name) ep##op##_##name
GET (curve, "P.curve -> elliptic curve containing P")
GET (point, "P.point -> standalone curve point")
{ 0 }
};
-static PyMethodDef ecpt_pymethods[] = {
+static const PyMethodDef ecpt_pymethods[] = {
#define METHNAME(func) epmeth_##func
- METH (toraw, "X.toraw() -> BIN")
+ NAMETH(toraw, "X.toraw() -> BIN")
KWMETH(ec2osp, "X.ec2osp([flags = EC_EXPLY]) -> BIN")
- METH (dbl, "X.dbl() -> X + X")
- METH (oncurvep, "X.oncurvep() -> BOOL")
+ NAMETH(dbl, "X.dbl() -> X + X")
+ NAMETH(oncurvep, "X.oncurvep() -> BOOL")
+ CMTH (fromraw, "fromraw(STR) -> (P, REST)")
+ KWCMTH(os2ecp, "os2ecp(STR, [flags = ...]) -> (P, REST)")
#undef METHNAME
{ 0 }
};
-static PyNumberMethods ecptcurve_pynumber = {
+static const PyNumberMethods ecptcurve_pynumber = {
ecpt_pyadd, /* @nb_add@ */
ecpt_pysub, /* @nb_subtract@ */
ecpt_pymul, /* @nb_multiply@ */
0, /* @tp_setattr@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
- &ecptcurve_pynumber, /* @tp_as_number@ */
+ PYNUMBER(ecptcurve), /* @tp_as_number@ */
0, /* @tp_as_sequence@ */
0, /* @tp_as_mapping@ */
0, /* @tp_hash@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Elliptic curve points; abstract base class for points on given curves.",
+ "Elliptic curve points; abstract base class for points on given curves.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- ecpt_pymethods, /* @tp_methods@ */
+ PYMETHODS(ecpt), /* @tp_methods@ */
0, /* @tp_members@ */
- ecpt_pygetset, /* @tp_getset@ */
+ PYGETSET(ecpt), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
ecmmul_id, ecmmul_fill, ecmmul_exp, ecmmul_drop));
}
-static PyObject *meth__ECPtCurve_fromraw(PyObject *me, PyObject *arg)
-{
- char *p;
- Py_ssize_t len;
- buf b;
- PyObject *rc = 0;
- ec_curve *cc;
- ec pp = EC_INIT;
-
- if (!PyArg_ParseTuple(arg, "Os#:fromraw", &me, &p, &len))
- return (0);
- buf_init(&b, p, len);
- cc = ECCURVE_C(me);
- if (ec_getraw(cc, &b, &pp))
- VALERR("bad point");
- EC_IN(cc, &pp, &pp);
- rc = Py_BuildValue("(NN)", ecpt_pywrap(me, &pp), bytestring_pywrapbuf(&b));
-end:
- return (rc);
-}
-
-static PyObject *meth__ECPtCurve_os2ecp(PyObject *me,
- PyObject *arg, PyObject *kw)
-{
- char *p;
- Py_ssize_t len;
- buf b;
- PyObject *rc = 0;
- ec_curve *cc;
- unsigned f = EC_XONLY | EC_LSB | EC_SORT | EC_EXPLY;
- ec pp = EC_INIT;
- char *kwlist[] = { "class", "buf", "flags", 0 };
-
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "Os#|O&:os2ecp", kwlist,
- &me, &p, &len, convuint, &f))
- return (0);
- buf_init(&b, p, len);
- cc = ECCURVE_C(me);
- if (ec_os2ecp(cc, f, &b, &pp)) VALERR("bad point");
- EC_IN(cc, &pp, &pp);
- rc = Py_BuildValue("(NN)", ecpt_pywrap(me, &pp), bytestring_pywrapbuf(&b));
-end:
- return (rc);
-}
-
-static PyObject *meth__ECPt_frombuf(PyObject *me, PyObject *arg)
-{
- buf b;
- char *p;
- Py_ssize_t sz;
- PyObject *rc = 0;
- ec pp = EC_INIT;
-
- if (!PyArg_ParseTuple(arg, "Os#:frombuf", &me, &p, &sz)) goto end;
- buf_init(&b, p, sz);
- if (buf_getec(&b, &pp)) VALERR("malformed data");
- rc = Py_BuildValue("(NN)", ecpt_pywrapout(me, &pp),
- bytestring_pywrapbuf(&b));
-end:
- return (rc);
-}
-
-static PyObject *meth__ECPt_parse(PyObject *me, PyObject *arg)
-{
- char *p;
- qd_parse qd;
- PyObject *rc = 0;
- ec pp = EC_INIT;
-
- if (!PyArg_ParseTuple(arg, "Os:parse", &me, &p)) goto end;
- qd.p = p;
- qd.e = 0;
- if (!ec_ptparse(&qd, &pp)) VALERR(qd.e);
- rc = Py_BuildValue("(Ns)", ecpt_pywrapout(me, &pp), qd.p);
-end:
- return (rc);
-}
-
static void eccurve_pydealloc(PyObject *me)
{
ec_destroycurve(ECCURVE_C(me));
static PyObject *ecmeth_rand(PyObject *me, PyObject *arg, PyObject *kw)
{
- char *kwlist[] = { "rng", 0 };
+ static const char *const kwlist[] = { "rng", 0 };
grand *r = &rand_global;
ec p = EC_INIT;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:rand", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:rand", KWLIST,
convgrand, &r))
return (0);
ec_rand(ECCURVE_C(me), &p, r);
return (ecpt_pywrap(me, &p));
}
+static PyObject *ecmeth_parse(PyObject *me, PyObject *arg)
+{
+ char *p;
+ qd_parse qd;
+ ec_curve *c;
+ PyObject *rc = 0;
+
+ if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
+ qd.p = p; qd.e = 0;
+ if ((c = ec_curveparse(&qd)) == 0) VALERR(qd.e);
+ rc = eccurve_pywrap(0, c);
+end:
+ return (rc);
+}
+
static PyObject *eccurve_dopywrap(PyTypeObject *ty,
PyObject *fobj, ec_curve *c)
{
else
Py_INCREF(fobj);
assert(FIELD_F(fobj) == c->f);
- if (strcmp(EC_NAME(c), "prime") == 0)
+ if (STRCMP(EC_NAME(c), ==, "prime"))
ty = ecprimecurve_pytype;
- else if (strcmp(EC_NAME(c), "primeproj") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "primeproj"))
ty = ecprimeprojcurve_pytype;
- else if (strcmp(EC_NAME(c), "bin") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "bin"))
ty = ecbincurve_pytype;
- else if (strcmp(EC_NAME(c), "binproj") == 0)
+ else if (STRCMP(EC_NAME(c), ==, "binproj"))
ty = ecbinprojcurve_pytype;
else
abort();
{
PyObject *fobj;
PyObject *cobj = 0;
- char *kwlist[] = { "field", "a", "b", 0 };
+ static const char *const kwlist[] = { "field", "a", "b", 0 };
mp *aa = 0, *bb = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&O&", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&O&", KWLIST,
field_pytype, &fobj,
convmp, &aa, convmp, &bb))
goto end;
return (cobj);
}
-static PyObject *meth__ECCurve_parse(PyObject *me, PyObject *arg)
-{
- char *p;
- qd_parse qd;
- ec_curve *c;
- PyObject *rc = 0;
-
- if (!PyArg_ParseTuple(arg, "Os:parse", &me, &p))
- goto end;
- qd.p = p;
- qd.e = 0;
- if ((c = ec_curveparse(&qd)) == 0)
- VALERR(qd.e);
- rc = eccurve_pywrap(0, c);
-end:
- return (rc);
-}
-
static PyObject *ecget_name(PyObject *me, void *hunoz)
{ return (PyString_FromString(EC_NAME(ECCURVE_C(me)))); }
static PyObject *ecget_inf(PyObject *me, void *hunoz)
{ ec inf = EC_INIT; return (ecpt_pywrap(me, &inf)); }
-static PyGetSetDef eccurve_pygetset[] = {
+static const PyGetSetDef eccurve_pygetset[] = {
#define GETSETNAME(op, name) ec##op##_##name
GET (name, "E.name -> name of this kind of curve")
GET (a, "E.a -> first parameter of curve")
{ 0 }
};
-static PyMethodDef eccurve_pymethods[] = {
+static const PyMethodDef eccurve_pymethods[] = {
#define METHNAME(name) ecmeth_##name
- METH (mmul, "\
-E.mmul([(P0, N0), (P1, N1), ...]) = N0 P0 + N1 P1 + ...")
+ METH (mmul, "E.mmul([(P0, N0), (P1, N1), ...]) = N0 P0 + N1 P1 + ...")
METH (find, "E.find(X) -> P")
- KWMETH(rand, "E.rand(rng = rand) ->P")
+ KWMETH(rand, "E.rand([rng = rand]) -> P")
+ SMTH (parse, "parse(STR) -> (E, REST)")
#undef METHNAME
{ 0 }
};
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- eccurve_pymethods, /* @tp_methods@ */
+ PYMETHODS(eccurve), /* @tp_methods@ */
0, /* @tp_members@ */
- eccurve_pygetset, /* @tp_getset@ */
+ PYGETSET(eccurve), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
- "An elliptic curve over a prime field. Use ecprimeprojcurve.",
+ "ECPrimeCurve(FIELD, A, B): an elliptic curve over a prime field.\n"
+ " Use ECPrimeProjCurve instead.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
- "An elliptic curve over a prime field, using projective coordinates.",
+ "ECPrimeProjCurve(FIELD, A, B): an elliptic curve over a prime field\n"
+ " using projective coordinates.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
- "An elliptic curve over a binary field. Use ecbinprojcurve.",
+ "ECBinCurve(FIELD, A, B): an elliptic curve over a binary field.\n"
+ " Use ECBinProjCurve instead.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
- "An elliptic curve over a binary field, using projective coordinates.",
+ "ECBinProjCurve(FIELD, A, B): an elliptic curve over a binary field,\n"
+ " using projective coordinates.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
{
ec_info ei = { 0 };
PyObject *e, *g;
- char *kwlist[] = { "curve", "G", "r", "h", 0 };
+ static const char *const kwlist[] = { "curve", "G", "r", "h", 0 };
ecinfo_pyobj *rc = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O!O&O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O!O&O&:new", KWLIST,
eccurve_pytype, &e, ecpt_pytype, &g,
convmp, &ei.r, convmp, &ei.h))
goto end;
return (0);
}
-static PyObject *meth__ECInfo_parse(PyObject *me, PyObject *arg)
+static PyObject *eimeth_parse(PyObject *me, PyObject *arg)
{
char *p;
qd_parse qd;
ec_info ei;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "Os:parse", &me, &p))
- goto end;
- qd.p = p;
- qd.e = 0;
- if (ec_infoparse(&qd, &ei))
- VALERR(qd.e);
+ if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
+ qd.p = p; qd.e = 0;
+ if (ec_infoparse(&qd, &ei)) VALERR(qd.e);
rc = Py_BuildValue("(Ns)", ecinfo_pywrap(&ei), qd.p);
end:
return (rc);
}
-static PyObject *meth__ECInfo__curven(PyObject *me, PyObject *arg)
+static PyObject *eimeth__curven(PyObject *me, PyObject *arg)
{
int i;
ec_info ei;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "Oi:_curven", &me, &i)) goto end;
+ if (!PyArg_ParseTuple(arg, "i:_curven", &i)) goto end;
if (i < 0 || i >= ncurves) VALERR("curve index out of range");
ec_infofromdata(&ei, ectab[i].data);
rc = ecinfo_pywrap(&ei);
static PyObject *eimeth_check(PyObject *me, PyObject *arg, PyObject *kw)
{
- char *kwlist[] = { "rng", 0 };
+ static const char *const kwlist[] = { "rng", 0 };
grand *r = &rand_global;
const char *p;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:check", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:check", KWLIST,
convgrand, &r))
goto end;
if ((p = ec_checkinfo(ECINFO_EI(me), r)) != 0)
static PyObject *eiget_h(PyObject *me, void *hunoz)
{ return (mp_pywrap(MP_COPY(ECINFO_EI(me)->h))); }
-static PyGetSetDef ecinfo_pygetset[] = {
+static const PyGetSetDef ecinfo_pygetset[] = {
#define GETSETNAME(op, name) ei##op##_##name
GET (curve, "I.curve -> the elliptic curve")
GET (G, "I.G -> generator point for the group")
{ 0 }
};
-static PyMethodDef ecinfo_pymethods[] = {
+static const PyMethodDef ecinfo_pymethods[] = {
#define METHNAME(name) eimeth_##name
KWMETH(check, "I.check([rng = rand]) -> None")
+ SMTH (parse, "parse(STR) -> (I, REST)")
+ SMTH (_curven, "_curven(N) -> I")
#undef METHNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
- "Elliptic curve domain parameters.",
+ "ECInfo(CURVE, G, R, H): elliptic curve domain parameters.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- ecinfo_pymethods, /* @tp_methods@ */
+ PYMETHODS(ecinfo), /* @tp_methods@ */
0, /* @tp_members@ */
- ecinfo_pygetset, /* @tp_getset@ */
+ PYGETSET(ecinfo), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
/*----- Setup -------------------------------------------------------------*/
-static PyMethodDef methods[] = {
-#define METHNAME(func) meth_##func
- METH (_ECPt_frombuf, "frombuf(E, STR) -> (P, REST)")
- METH (_ECPtCurve_fromraw, "fromraw(E, STR) -> (P, REST)")
- KWMETH(_ECPtCurve_os2ecp, "os2ecp(E, STR, [flags = ...]) -> (P, REST)")
- METH (_ECPt_parse, "parse(E, STR) -> (P, REST)")
- METH (_ECCurve_parse, "parse(STR) -> (E, REST)")
- METH (_ECInfo_parse, "parse(STR) -> (I, REST)")
- METH (_ECInfo__curven, "_curven(N) -> I")
-#undef METHNAME
- { 0 }
-};
-
void ec_pyinit(void)
{
INITTYPE(ecpt, root);
INITTYPE(ecbincurve, eccurve);
INITTYPE(ecbinprojcurve, ecbincurve);
INITTYPE(ecinfo, root);
- addmethods(methods);
}
static PyObject *namedcurves(void)
~mdw / catacomb-python / blobdiff