~mdw / catacomb-python / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mp.c: Factor out and export `mphash'.
[catacomb-python] / field.c
1 /* -*-c-*-
2 *
3 * Abstract fields
4 *
5 * (c) 2004 Straylight/Edgeware
6 */
7
8 /*----- Licensing notice --------------------------------------------------*
9 *
10 * This file is part of the Python interface to Catacomb.
11 *
12 * Catacomb/Python is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * Catacomb/Python is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with Catacomb/Python; if not, write to the Free Software Foundation,
24 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 */
26
27 /*----- Header files ------------------------------------------------------*/
28
29 #include "catacomb-python.h"
30
31 /*----- Various utilities -------------------------------------------------*/
32
33 PyTypeObject *field_pytype;
34 PyTypeObject *primefield_pytype;
35 PyTypeObject *niceprimefield_pytype;
36 PyTypeObject *binfield_pytype;
37 PyTypeObject *binpolyfield_pytype;
38 PyTypeObject *binnormfield_pytype;
39 PyTypeObject *fe_pytype;
40
41 static PyObject *fe_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
42 {
43 PyObject *x;
44 mp *z;
45 char *kwlist[] = { "x", 0 };
46
47 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O:fe", kwlist, &x))
48 return (0);
49 if (FE_PYCHECK(x) && FE_F(x) == FIELD_F(ty)) RETURN_OBJ(x);
50 if ((z = getmp(x)) == 0) return (0);
51 z = F_IN(FIELD_F(ty), z, z);
52 return (fe_pywrap((PyObject *)ty, z));
53 }
54
55 static PyObject *field_dopywrap(PyTypeObject *ty, field *f)
56 {
57 field_pyobj *fobj = newtype(ty, 0, f->ops->name);
58 fobj->f = f;
59 fobj->ty.ht_type.tp_basicsize = sizeof(fe_pyobj);
60 fobj->ty.ht_type.tp_base = fe_pytype;
61 Py_INCREF(fe_pytype);
62 fobj->ty.ht_type.tp_flags = (Py_TPFLAGS_DEFAULT |
63 Py_TPFLAGS_BASETYPE |
64 Py_TPFLAGS_CHECKTYPES |
65 Py_TPFLAGS_HEAPTYPE);
66 fobj->ty.ht_type.tp_alloc = PyType_GenericAlloc;
67 fobj->ty.ht_type.tp_free = 0;
68 fobj->ty.ht_type.tp_new = fe_pynew;
69 typeready(&fobj->ty.ht_type);
70 return ((PyObject *)fobj);
71 }
72
73 PyObject *field_pywrap(field *f)
74 {
75 PyTypeObject *ty;
76
77 if (strcmp(F_NAME(f), "prime") == 0) ty = primefield_pytype;
78 else if (strcmp(F_NAME(f), "niceprime") == 0) ty = niceprimefield_pytype;
79 else if (strcmp(F_NAME(f), "binpoly") == 0) ty = binpolyfield_pytype;
80 else if (strcmp(F_NAME(f), "binnorm") == 0) ty = binnormfield_pytype;
81 else abort();
82 return (field_dopywrap(ty, f));
83 }
84
85 field *field_copy(field *f)
86 {
87 if (strcmp(F_NAME(f), "prime") == 0)
88 f = field_prime(f->m);
89 else if (strcmp(F_NAME(f), "niceprime") == 0)
90 f = field_niceprime(f->m);
91 else if (strcmp(F_NAME(f), "binpoly") == 0)
92 f = field_binpoly(f->m);
93 else if (strcmp(F_NAME(f), "binnorm") == 0) {
94 fctx_binnorm *fc = (fctx_binnorm *)f;
95 f = field_binnorm(f->m, fc->ntop.r[fc->ntop.n - 1]);
96 } else
97 abort();
98 return (f);
99 }
100
101 PyObject *fe_pywrap(PyObject *fobj, mp *x)
102 {
103 fe_pyobj *z = PyObject_New(fe_pyobj, (PyTypeObject *)fobj);
104 z->f = FIELD_F(fobj);
105 Py_INCREF(fobj);
106 z->x = x;
107 return ((PyObject *)z);
108 }
109
110 static mp *tofe(field *f, PyObject *o)
111 {
112 mp *x = 0, *y = 0;
113
114 if (FE_PYCHECK(o)) {
115 if (FE_F(o) != f && !field_samep(FE_F(o), f)) return (0);
116 y = MP_COPY(FE_X(o));
117 } else if ((x = tomp(o)) != 0) {
118 if (MP_ZEROP(x))
119 y = MP_COPY(f->zero);
120 else if (MP_EQ(x, MP_ONE))
121 y = MP_COPY(f->one);
122 else
123 y = F_IN(f, MP_NEW, x);
124 MP_DROP(x);
125 }
126 return (y);
127 }
128
129 mp *getfe(field *f, PyObject *o)
130 {
131 mp *x = 0;
132 if ((x = tofe(f, o)) == 0) {
133 PyErr_Format(PyExc_TypeError, "can't convert %.100s to fe",
134 o->ob_type->tp_name);
135 }
136 return (x);
137 }
138
139 /*----- Field elements ----------------------------------------------------*/
140
141 static int febinop(PyObject *x, PyObject *y,
142 field **f, PyObject **fobj, mp **xx, mp **yy)
143 {
144 if (FE_PYCHECK(x)) *fobj = FE_FOBJ(x);
145 else if (FE_PYCHECK(y)) *fobj = FE_FOBJ(y);
146 else return (-1);
147 *f = FIELD_F(*fobj);
148 if ((*xx = tofe(*f, x)) == 0)
149 return (-1);
150 if ((*yy = tofe(*f, y)) == 0) {
151 MP_DROP(*xx);
152 return (-1);
153 }
154 return (0);
155 }
156
157 #define BINOP(name) \
158 static PyObject *fe_py##name(PyObject *x, PyObject *y) { \
159 PyObject *fobj; \
160 field *ff; \
161 mp *xx, *yy, *zz; \
162 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL; \
163 zz = ff->ops->name(ff, MP_NEW, xx, yy); \
164 MP_DROP(xx); MP_DROP(yy); \
165 return (fe_pywrap(fobj, zz)); \
166 }
167 BINOP(add)
168 BINOP(sub)
169 BINOP(mul)
170 #undef BINOP
171
172 static PyObject *fe_pydiv(PyObject *x, PyObject *y)
173 {
174 PyObject *fobj;
175 field *ff;
176 mp *xx, *yy;
177 PyObject *z = 0;
178 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL;
179 if (F_ZEROP(ff, yy)) ZDIVERR("division by zero");
180 yy = F_INV(ff, yy, yy);
181 z = fe_pywrap(fobj, F_MUL(ff, MP_NEW, xx, yy));
182 end:
183 MP_DROP(xx); MP_DROP(yy);
184 return (z);
185 }
186
187 static PyObject *fe_pyexp(PyObject *x, PyObject *y, PyObject *z)
188 {
189 field *ff;
190 mp *xx, *yy;
191
192 if (z != Py_None || !FE_PYCHECK(x) || (yy = tomp(y)) == 0)
193 RETURN_NOTIMPL;
194 ff = FE_F(x); xx = FE_X(x); MP_COPY(xx);
195 if (MP_NEGP(yy) && F_ZEROP(ff, xx)) ZDIVERR("division by zero");
196 z = fe_pywrap(FE_FOBJ(x), field_exp(ff, MP_NEW, xx, yy));
197 end:
198 MP_DROP(xx); MP_DROP(yy);
199 return (z);
200 }
201
202 static PyObject *fe_pyneg(PyObject *x)
203 {
204 return fe_pywrap(FE_FOBJ(x), FE_F(x)->ops->neg(FE_F(x), MP_NEW, FE_X(x)));
205 }
206
207 static PyObject *fe_pyid(PyObject *x) { RETURN_OBJ(x); }
208
209 static int fe_pynonzerop(PyObject *x) { return !F_ZEROP(FE_F(x), FE_X(x)); }
210
211 static PyObject *fe_pyrichcompare(PyObject *x, PyObject *y, int op)
212 {
213 PyObject *fobj;
214 field *ff;
215 mp *xx, *yy;
216 int b;
217 PyObject *rc = 0;
218
219 if (febinop(x, y, &ff, &fobj, &xx, &yy)) RETURN_NOTIMPL;
220 switch (op) {
221 case Py_EQ: b = MP_EQ(xx, yy); break;
222 case Py_NE: b = !MP_EQ(xx, yy); break;
223 default: TYERR("field elements are unordered");
224 }
225 rc = getbool(b);
226 end:
227 MP_DROP(xx); MP_DROP(yy);
228 return (rc);
229 }
230
231 static long fe_pyhash(PyObject *me)
232 {
233 size_t sz = FE_F(me)->noctets;
234 uint32 h = 0xe0c127ca + FE_F(me)->ops->ty;
235 octet *p = xmalloc(sz);
236 mp_storeb(FE_X(me), p, sz);
237 h = unihash_hash(&unihash_global, h, p, sz);
238 xfree(p);
239 return (h % LONG_MAX);
240 }
241
242 static int fe_pycoerce(PyObject **x, PyObject **y)
243 {
244 mp *z;
245
246 if (FE_PYCHECK(*y)) {
247 if (FE_F(*x) != FE_F(*y) && !field_samep(FE_F(*x), FE_F(*y)))
248 TYERR("field mismatch");
249 Py_INCREF(*x); Py_INCREF(*y);
250 return (0);
251 }
252 if ((z = tofe(FE_F(*x), *y)) != 0) {
253 Py_INCREF(*x);
254 *y = fe_pywrap(FE_FOBJ(*x), z);
255 return (0);
256 }
257 return (1);
258
259 end:
260 return (-1);
261 }
262
263 static PyObject *fe_pyint(PyObject *x)
264 {
265 long l;
266 PyObject *rc;
267 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x));
268 if (!mp_tolong_checked(xx, &l, 0)) rc = PyInt_FromLong(l);
269 else rc = mp_topylong(xx);
270 MP_DROP(xx);
271 return (rc);
272 }
273
274 static PyObject *fe_pylong(PyObject *x)
275 {
276 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x));
277 PyObject *rc = mp_topylong(xx);
278 MP_DROP(xx);
279 return (rc);
280 }
281
282 #define BASEOP(name, radix, pre) \
283 static PyObject *fe_py##name(PyObject *x) { \
284 mp *xx = F_OUT(FE_F(x), MP_NEW, FE_X(x)); \
285 PyObject *rc = mp_topystring(FE_X(x), radix, 0, pre, 0); \
286 MP_DROP(xx); \
287 return (rc); \
288 }
289 BASEOP(oct, 8, "0");
290 BASEOP(hex, 16, "0x");
291 #undef BASEOP
292
293 static void fe_pydealloc(PyObject *me)
294 {
295 Py_DECREF(FE_FOBJ(me));
296 MP_DROP(FE_X(me));
297 FREEOBJ(me);
298 }
299
300 #define UNOP(name, check) \
301 static PyObject *femeth_##name(PyObject *me, PyObject *arg) { \
302 field *f = FE_F(me); \
303 mp *x = FE_X(me); \
304 if (!PyArg_ParseTuple(arg, ":" #name)) return (0); \
305 if (!f->ops->name) TYERR(#name " not supported for this field"); \
306 check \
307 x = f->ops->name(f, MP_NEW, x); \
308 if (!x) RETURN_NONE; \
309 return (fe_pywrap(FE_FOBJ(me), x)); \
310 end: \
311 return (0); \
312 }
313 UNOP(inv, if (F_ZEROP(f, x)) ZDIVERR("division by zero"); )
314 UNOP(sqr, ; )
315 UNOP(sqrt, ; )
316 UNOP(quadsolve, ; )
317 UNOP(dbl, ; )
318 UNOP(tpl, ; )
319 UNOP(qdl, ; )
320 UNOP(hlv, ; )
321 #undef UNOP
322
323 static PyObject *feget_field(PyObject *me, void *hunoz)
324 { RETURN_OBJ(FE_FOBJ(me)); }
325
326 static PyObject *feget_value(PyObject *me, void *hunoz)
327 {
328 mp *x = F_OUT(FE_F(me), MP_NEW, FE_X(me));
329 if (F_TYPE(FE_F(me)) == FTY_BINARY)
330 return (gf_pywrap(x));
331 else
332 return (mp_pywrap(x));
333 }
334
335 static PyObject *feget__value(PyObject *me, void *hunoz)
336 {
337 mp *x = FE_X(me);
338 MP_COPY(x);
339 if (F_TYPE(FE_F(me)) == FTY_BINARY)
340 return (gf_pywrap(x));
341 else
342 return (mp_pywrap(x));
343 }
344
345 static PyGetSetDef fe_pygetset[] = {
346 #define GETSETNAME(op, name) fe##op##_##name
347 GET (field, "X.field -> field containing X")
348 GET (value, "X.value -> `natural' integer representation of X")
349 GET (_value, "X._value -> internal integer representation of X")
350 #undef GETSETNAME
351 { 0 }
352 };
353
354 static PyMethodDef fe_pymethods[] = {
355 #define METHNAME(func) femeth_##func
356 METH (inv, "X.inv() -> X^{-1}")
357 METH (sqr, "X.sqr() -> X^2")
358 METH (sqrt, "X.sqrt() -> sqrt(X)")
359 METH (quadsolve, "X.quadsolve() -> Y where Y^2 + Y = X (binary only)")
360 METH (dbl, "X.dbl() -> 2 * X (prime only)")
361 METH (tpl, "X.tpl() -> 3 * X (prime only)")
362 METH (qdl, "X.qdl() -> 4 * X (prime only)")
363 METH (hlv, "X.hlv() -> X/2 (prime only)")
364 #undef METHNAME
365 { 0 }
366 };
367
368 static PyNumberMethods fe_pynumber = {
369 fe_pyadd, /* @nb_add@ */
370 fe_pysub, /* @nb_subtract@ */
371 fe_pymul, /* @nb_multiply@ */
372 fe_pydiv, /* @nb_divide@ */
373 0, /* @nb_remainder@ */
374 0, /* @nb_divmod@ */
375 fe_pyexp, /* @nb_power@ */
376 fe_pyneg, /* @nb_negative@ */
377 fe_pyid, /* @nb_positive@ */
378 0, /* @nb_absolute@ */
379 fe_pynonzerop, /* @nb_nonzero@ */
380 0, /* @nb_invert@ */
381 0, /* @nb_lshift@ */
382 0, /* @nb_rshift@ */
383 0, /* @nb_and@ */
384 0, /* @nb_xor@ */
385 0, /* @nb_or@ */
386 fe_pycoerce, /* @nb_coerce@ */
387 fe_pyint, /* @nb_int@ */
388 fe_pylong, /* @nb_long@ */
389 0 /* meaningless */, /* @nb_float@ */
390 fe_pyoct, /* @nb_oct@ */
391 fe_pyhex, /* @nb_hex@ */
392
393 0, /* @nb_inplace_add@ */
394 0, /* @nb_inplace_subtract@ */
395 0, /* @nb_inplace_multiply@ */
396 0, /* @nb_inplace_divide@ */
397 0, /* @nb_inplace_remainder@ */
398 0, /* @nb_inplace_power@ */
399 0, /* @nb_inplace_lshift@ */
400 0, /* @nb_inplace_rshift@ */
401 0, /* @nb_inplace_and@ */
402 0, /* @nb_inplace_xor@ */
403 0, /* @nb_inplace_or@ */
404
405 0, /* @nb_floor_divide@ */
406 fe_pydiv, /* @nb_true_divide@ */
407 0, /* @nb_inplace_floor_divide@ */
408 0, /* @nb_inplace_true_divide@ */
409 };
410
411 static PyTypeObject fe_pytype_skel = {
412 PyObject_HEAD_INIT(0) 0, /* Header */
413 "FE", /* @tp_name@ */
414 sizeof(fe_pyobj), /* @tp_basicsize@ */
415 0, /* @tp_itemsize@ */
416
417 fe_pydealloc, /* @tp_dealloc@ */
418 0, /* @tp_print@ */
419 0, /* @tp_getattr@ */
420 0, /* @tp_setattr@ */
421 0, /* @tp_compare@ */
422 0, /* @tp_repr@ */
423 &fe_pynumber, /* @tp_as_number@ */
424 0, /* @tp_as_sequence@ */
425 0, /* @tp_as_mapping@ */
426 fe_pyhash, /* @tp_hash@ */
427 0, /* @tp_call@ */
428 fe_pyhex, /* @tp_str@ */
429 0, /* @tp_getattro@ */
430 0, /* @tp_setattro@ */
431 0, /* @tp_as_buffer@ */
432 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
433 Py_TPFLAGS_CHECKTYPES |
434 Py_TPFLAGS_BASETYPE,
435
436 /* @tp_doc@ */
437 "Finite field elements, abstract base class.",
438
439 0, /* @tp_traverse@ */
440 0, /* @tp_clear@ */
441 fe_pyrichcompare, /* @tp_richcompare@ */
442 0, /* @tp_weaklistoffset@ */
443 0, /* @tp_iter@ */
444 0, /* @tp_iternext@ */
445 fe_pymethods, /* @tp_methods@ */
446 0, /* @tp_members@ */
447 fe_pygetset, /* @tp_getset@ */
448 0, /* @tp_base@ */
449 0, /* @tp_dict@ */
450 0, /* @tp_descr_get@ */
451 0, /* @tp_descr_set@ */
452 0, /* @tp_dictoffset@ */
453 0, /* @tp_init@ */
454 PyType_GenericAlloc, /* @tp_alloc@ */
455 abstract_pynew, /* @tp_new@ */
456 0, /* @tp_free@ */
457 0 /* @tp_is_gc@ */
458 };
459
460 /*----- Fields ------------------------------------------------------------*/
461
462 static PyObject *field_pyrichcompare(PyObject *x, PyObject *y, int op)
463 {
464 int b = field_samep(FIELD_F(x), FIELD_F(y));
465 switch (op) {
466 case Py_EQ: break;
467 case Py_NE: b = !b;
468 default: TYERR("can't order fields");
469 }
470 return (getbool(b));
471 end:
472 return (0);
473 }
474
475 static PyObject *fmeth_rand(PyObject *me, PyObject *arg, PyObject *kw)
476 {
477 char *kwlist[] = { "rng", 0 };
478 grand *r = &rand_global;
479
480 if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:rand", kwlist,
481 convgrand, &r))
482 return (0);
483 return (fe_pywrap(me, F_RAND(FIELD_F(me), MP_NEW, r)));
484 }
485
486 static PyObject *fmeth__adopt(PyObject *me, PyObject *arg)
487 {
488 mp *xx;
489 if (!PyArg_ParseTuple(arg, "O&:_adopt", convmp, &xx)) return (0);
490 return (fe_pywrap(me, xx));
491 }
492
493 static void field_pydealloc(PyObject *me)
494 {
495 F_DESTROY(FIELD_F(me));
496 PyType_Type.tp_dealloc(me);
497 }
498
499 static PyObject *fget_zero(PyObject *me, void *hunoz)
500 { return (fe_pywrap(me, MP_COPY(FIELD_F(me)->zero))); }
501
502 static PyObject *fget_one(PyObject *me, void *hunoz)
503 { return (fe_pywrap(me, MP_COPY(FIELD_F(me)->one))); }
504
505 static PyObject *fget_q(PyObject *me, void *hunoz)
506 { return (mp_pywrap(MP_COPY(FIELD_F(me)->q))); }
507
508 static PyObject *fget_nbits(PyObject *me, void *hunoz)
509 { return (PyInt_FromLong(FIELD_F(me)->nbits)); }
510
511 static PyObject *fget_noctets(PyObject *me, void *hunoz)
512 { return (PyInt_FromLong(FIELD_F(me)->noctets)); }
513
514 static PyObject *fget_name(PyObject *me, void *hunoz)
515 { return (PyString_FromString(F_NAME(FIELD_F(me)))); }
516
517 static PyObject *fget_type(PyObject *me, void *hunoz)
518 { return (PyInt_FromLong(F_TYPE(FIELD_F(me)))); }
519
520 static PyGetSetDef field_pygetset[] = {
521 #define GETSETNAME(op, name) f##op##_##name
522 GET (zero, "F.zero -> field additive identity")
523 GET (one, "F.one -> field multiplicative identity")
524 GET (q, "F.q -> number of elements in field")
525 GET (nbits, "F.nbits -> bits needed to represent element")
526 GET (noctets, "F.noctets -> octetss needed to represent element")
527 GET (name, "F.name -> name of this kind of field")
528 GET (type, "F.type -> type code of this kind of field")
529 #undef GETSETNAME
530 { 0 }
531 };
532
533 static PyMethodDef field_pymethods[] = {
534 #define METHNAME(name) fmeth_##name
535 METH (_adopt, "F._adopt(X) -> FE")
536 KWMETH(rand, "F.rand(rng = rand) -> FE, uniformly distributed")
537 #undef METHNAME
538 { 0 }
539 };
540
541 static PyTypeObject field_pytype_skel = {
542 PyObject_HEAD_INIT(0) 0, /* Header */
543 "Field", /* @tp_name@ */
544 sizeof(field_pyobj), /* @tp_basicsize@ */
545 0, /* @tp_itemsize@ */
546
547 field_pydealloc, /* @tp_dealloc@ */
548 0, /* @tp_print@ */
549 0, /* @tp_getattr@ */
550 0, /* @tp_setattr@ */
551 0, /* @tp_compare@ */
552 0, /* @tp_repr@ */
553 0, /* @tp_as_number@ */
554 0, /* @tp_as_sequence@ */
555 0, /* @tp_as_mapping@ */
556 0, /* @tp_hash@ */
557 0, /* @tp_call@ */
558 0, /* @tp_str@ */
559 0, /* @tp_getattro@ */
560 0, /* @tp_setattro@ */
561 0, /* @tp_as_buffer@ */
562 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
563 Py_TPFLAGS_BASETYPE,
564
565 /* @tp_doc@ */
566 "An abstract field. This is an abstract type.",
567
568 0, /* @tp_traverse@ */
569 0, /* @tp_clear@ */
570 field_pyrichcompare, /* @tp_richcompare@ */
571 0, /* @tp_weaklistoffset@ */
572 0, /* @tp_iter@ */
573 0, /* @tp_iternext@ */
574 field_pymethods, /* @tp_methods@ */
575 0, /* @tp_members@ */
576 field_pygetset, /* @tp_getset@ */
577 0, /* @tp_base@ */
578 0, /* @tp_dict@ */
579 0, /* @tp_descr_get@ */
580 0, /* @tp_descr_set@ */
581 0, /* @tp_dictoffset@ */
582 0, /* @tp_init@ */
583 PyType_GenericAlloc, /* @tp_alloc@ */
584 abstract_pynew, /* @tp_new@ */
585 0, /* @tp_free@ */
586 0 /* @tp_is_gc@ */
587 };
588
589 /*----- Prime fields ------------------------------------------------------*/
590
591 static PyObject *primefield_pynew(PyTypeObject *ty,
592 PyObject *arg, PyObject *kw)
593 {
594 mp *xx = 0;
595 field *f;
596 char *kwlist[] = { "p", 0 };
597
598 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:primefield", kwlist,
599 convmp, &xx))
600 goto end;
601 if ((f = field_prime(xx)) == 0)
602 VALERR("bad prime for primefield");
603 MP_DROP(xx);
604 return (field_dopywrap(ty, f));
605 end:
606 mp_drop(xx);
607 return (0);
608 }
609
610 static PyObject *pfget_p(PyObject *me, void *hunoz)
611 { return (mp_pywrap(MP_COPY(FIELD_F(me)->m))); }
612
613 static PyGetSetDef primefield_pygetset[] = {
614 #define GETSETNAME(op, name) pf##op##_##name
615 GET (p, "F.p -> prime field characteristic")
616 #undef GETSETNAME
617 };
618
619 static PyTypeObject primefield_pytype_skel = {
620 PyObject_HEAD_INIT(0) 0, /* Header */
621 "PrimeField", /* @tp_name@ */
622 sizeof(field_pyobj), /* @tp_basicsize@ */
623 0, /* @tp_itemsize@ */
624
625 field_pydealloc, /* @tp_dealloc@ */
626 0, /* @tp_print@ */
627 0, /* @tp_getattr@ */
628 0, /* @tp_setattr@ */
629 0, /* @tp_compare@ */
630 0, /* @tp_repr@ */
631 0, /* @tp_as_number@ */
632 0, /* @tp_as_sequence@ */
633 0, /* @tp_as_mapping@ */
634 0, /* @tp_hash@ */
635 0, /* @tp_call@ */
636 0, /* @tp_str@ */
637 0, /* @tp_getattro@ */
638 0, /* @tp_setattro@ */
639 0, /* @tp_as_buffer@ */
640 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
641 Py_TPFLAGS_BASETYPE,
642
643 /* @tp_doc@ */
644 "Prime fields.",
645
646 0, /* @tp_traverse@ */
647 0, /* @tp_clear@ */
648 field_pyrichcompare, /* @tp_richcompare@ */
649 0, /* @tp_weaklistoffset@ */
650 0, /* @tp_iter@ */
651 0, /* @tp_iternext@ */
652 0, /* @tp_methods@ */
653 0, /* @tp_members@ */
654 primefield_pygetset, /* @tp_getset@ */
655 0, /* @tp_base@ */
656 0, /* @tp_dict@ */
657 0, /* @tp_descr_get@ */
658 0, /* @tp_descr_set@ */
659 0, /* @tp_dictoffset@ */
660 0, /* @tp_init@ */
661 PyType_GenericAlloc, /* @tp_alloc@ */
662 primefield_pynew, /* @tp_new@ */
663 0, /* @tp_free@ */
664 0 /* @tp_is_gc@ */
665 };
666
667 static PyObject *niceprimefield_pynew(PyTypeObject *ty,
668 PyObject *arg, PyObject *kw)
669 {
670 mp *xx = 0;
671 field *f;
672 char *kwlist[] = { "p", 0 };
673
674 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:niceprimefield",
675 kwlist, convmp, &xx))
676 goto end;
677 if ((f = field_niceprime(xx)) == 0)
678 VALERR("bad prime for niceprimefield");
679 MP_DROP(xx);
680 return (field_dopywrap(ty, f));
681 end:
682 mp_drop(xx);
683 return (0);
684 }
685
686 static PyTypeObject niceprimefield_pytype_skel = {
687 PyObject_HEAD_INIT(0) 0, /* Header */
688 "NicePrimeField", /* @tp_name@ */
689 sizeof(field_pyobj), /* @tp_basicsize@ */
690 0, /* @tp_itemsize@ */
691
692 field_pydealloc, /* @tp_dealloc@ */
693 0, /* @tp_print@ */
694 0, /* @tp_getattr@ */
695 0, /* @tp_setattr@ */
696 0, /* @tp_compare@ */
697 0, /* @tp_repr@ */
698 0, /* @tp_as_number@ */
699 0, /* @tp_as_sequence@ */
700 0, /* @tp_as_mapping@ */
701 0, /* @tp_hash@ */
702 0, /* @tp_call@ */
703 0, /* @tp_str@ */
704 0, /* @tp_getattro@ */
705 0, /* @tp_setattro@ */
706 0, /* @tp_as_buffer@ */
707 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
708 Py_TPFLAGS_BASETYPE,
709
710 /* @tp_doc@ */
711 "Nice prime fields.",
712
713 0, /* @tp_traverse@ */
714 0, /* @tp_clear@ */
715 field_pyrichcompare, /* @tp_richcompare@ */
716 0, /* @tp_weaklistoffset@ */
717 0, /* @tp_iter@ */
718 0, /* @tp_iternext@ */
719 0, /* @tp_methods@ */
720 0, /* @tp_members@ */
721 0, /* @tp_getset@ */
722 0, /* @tp_base@ */
723 0, /* @tp_dict@ */
724 0, /* @tp_descr_get@ */
725 0, /* @tp_descr_set@ */
726 0, /* @tp_dictoffset@ */
727 0, /* @tp_init@ */
728 PyType_GenericAlloc, /* @tp_alloc@ */
729 niceprimefield_pynew, /* @tp_new@ */
730 0, /* @tp_free@ */
731 0 /* @tp_is_gc@ */
732 };
733
734 /*----- Binary fields -----------------------------------------------------*/
735
736 static PyObject *bfget_m(PyObject *me, void *hunoz)
737 { return (PyInt_FromLong(FIELD_F(me)->nbits)); }
738
739 static PyGetSetDef binfield_pygetset[] = {
740 #define GETSETNAME(op, name) bf##op##_##name
741 GET (m, "F.m -> field polynomial degree")
742 #undef GETSETNAME
743 { 0 }
744 };
745
746 static PyTypeObject binfield_pytype_skel = {
747 PyObject_HEAD_INIT(0) 0, /* Header */
748 "BinField", /* @tp_name@ */
749 sizeof(field_pyobj), /* @tp_basicsize@ */
750 0, /* @tp_itemsize@ */
751
752 field_pydealloc, /* @tp_dealloc@ */
753 0, /* @tp_print@ */
754 0, /* @tp_getattr@ */
755 0, /* @tp_setattr@ */
756 0, /* @tp_compare@ */
757 0, /* @tp_repr@ */
758 0, /* @tp_as_number@ */
759 0, /* @tp_as_sequence@ */
760 0, /* @tp_as_mapping@ */
761 0, /* @tp_hash@ */
762 0, /* @tp_call@ */
763 0, /* @tp_str@ */
764 0, /* @tp_getattro@ */
765 0, /* @tp_setattro@ */
766 0, /* @tp_as_buffer@ */
767 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
768 Py_TPFLAGS_BASETYPE,
769
770 /* @tp_doc@ */
771 "Binary fields. Abstract class.",
772
773 0, /* @tp_traverse@ */
774 0, /* @tp_clear@ */
775 field_pyrichcompare, /* @tp_richcompare@ */
776 0, /* @tp_weaklistoffset@ */
777 0, /* @tp_iter@ */
778 0, /* @tp_iternext@ */
779 0, /* @tp_methods@ */
780 0, /* @tp_members@ */
781 binfield_pygetset, /* @tp_getset@ */
782 0, /* @tp_base@ */
783 0, /* @tp_dict@ */
784 0, /* @tp_descr_get@ */
785 0, /* @tp_descr_set@ */
786 0, /* @tp_dictoffset@ */
787 0, /* @tp_init@ */
788 PyType_GenericAlloc, /* @tp_alloc@ */
789 abstract_pynew, /* @tp_new@ */
790 0, /* @tp_free@ */
791 0 /* @tp_is_gc@ */
792 };
793
794 static PyObject *binpolyfield_pynew(PyTypeObject *ty,
795 PyObject *arg, PyObject *kw)
796 {
797 mp *xx = 0;
798 field *f;
799 char *kwlist[] = { "p", 0 };
800
801 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:binpolyfield", kwlist,
802 convgf, &xx))
803 goto end;
804 if ((f = field_binpoly(xx)) == 0) VALERR("bad poly for binpolyfield");
805 MP_DROP(xx);
806 return (field_dopywrap(ty, f));
807 end:
808 mp_drop(xx);
809 return (0);
810 }
811
812 static PyGetSetDef binpolyfield_pygetset[] = {
813 #define GETSETNAME(op, name) pf##op##_##name
814 GET (p, "F.p -> field polynomial")
815 #undef GETSETNAME
816 { 0 }
817 };
818
819 static PyTypeObject binpolyfield_pytype_skel = {
820 PyObject_HEAD_INIT(0) 0, /* Header */
821 "BinPolyField", /* @tp_name@ */
822 sizeof(field_pyobj), /* @tp_basicsize@ */
823 0, /* @tp_itemsize@ */
824
825 field_pydealloc, /* @tp_dealloc@ */
826 0, /* @tp_print@ */
827 0, /* @tp_getattr@ */
828 0, /* @tp_setattr@ */
829 0, /* @tp_compare@ */
830 0, /* @tp_repr@ */
831 0, /* @tp_as_number@ */
832 0, /* @tp_as_sequence@ */
833 0, /* @tp_as_mapping@ */
834 0, /* @tp_hash@ */
835 0, /* @tp_call@ */
836 0, /* @tp_str@ */
837 0, /* @tp_getattro@ */
838 0, /* @tp_setattro@ */
839 0, /* @tp_as_buffer@ */
840 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
841 Py_TPFLAGS_BASETYPE,
842
843 /* @tp_doc@ */
844 "Binary fields with polynomial basis representation.",
845
846 0, /* @tp_traverse@ */
847 0, /* @tp_clear@ */
848 field_pyrichcompare, /* @tp_richcompare@ */
849 0, /* @tp_weaklistoffset@ */
850 0, /* @tp_iter@ */
851 0, /* @tp_iternext@ */
852 0, /* @tp_methods@ */
853 0, /* @tp_members@ */
854 binpolyfield_pygetset, /* @tp_getset@ */
855 0, /* @tp_base@ */
856 0, /* @tp_dict@ */
857 0, /* @tp_descr_get@ */
858 0, /* @tp_descr_set@ */
859 0, /* @tp_dictoffset@ */
860 0, /* @tp_init@ */
861 PyType_GenericAlloc, /* @tp_alloc@ */
862 binpolyfield_pynew, /* @tp_new@ */
863 0, /* @tp_free@ */
864 0 /* @tp_is_gc@ */
865 };
866
867 static PyObject *binnormfield_pynew(PyTypeObject *ty,
868 PyObject *arg, PyObject *kw)
869 {
870 mp *xx = 0, *yy = 0;
871 field *f;
872 char *kwlist[] = { "p", "beta", 0 };
873
874 if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:binnormfield",
875 kwlist, convgf, &xx, convgf, &yy))
876 goto end;
877 if ((f = field_binnorm(xx, yy)) == 0) VALERR("bad args for binnormfield");
878 MP_DROP(xx); MP_DROP(yy);
879 return (field_dopywrap(ty, f));
880 end:
881 mp_drop(xx); mp_drop(yy);
882 return (0);
883 }
884
885 static PyObject *bnfget_beta(PyObject *me, void *hunoz)
886 {
887 fctx_binnorm *fc = (fctx_binnorm *)FIELD_F(me);
888 return (gf_pywrap(MP_COPY(fc->ntop.r[fc->ntop.n - 1])));
889 }
890
891 static PyGetSetDef binnormfield_pygetset[] = {
892 #define GETSETNAME(op, name) pf##op##_##name
893 GET (p, "F.p -> field polynomial")
894 #undef GETSETNAME
895 #define GETSETNAME(op, name) bnf##op##_##name
896 GET (beta, "F.beta -> conversion factor")
897 #undef GETSETNAME
898 { 0 }
899 };
900
901 static PyTypeObject binnormfield_pytype_skel = {
902 PyObject_HEAD_INIT(0) 0, /* Header */
903 "BinNormField", /* @tp_name@ */
904 sizeof(field_pyobj), /* @tp_basicsize@ */
905 0, /* @tp_itemsize@ */
906
907 field_pydealloc, /* @tp_dealloc@ */
908 0, /* @tp_print@ */
909 0, /* @tp_getattr@ */
910 0, /* @tp_setattr@ */
911 0, /* @tp_compare@ */
912 0, /* @tp_repr@ */
913 0, /* @tp_as_number@ */
914 0, /* @tp_as_sequence@ */
915 0, /* @tp_as_mapping@ */
916 0, /* @tp_hash@ */
917 0, /* @tp_call@ */
918 0, /* @tp_str@ */
919 0, /* @tp_getattro@ */
920 0, /* @tp_setattro@ */
921 0, /* @tp_as_buffer@ */
922 Py_TPFLAGS_DEFAULT | /* @tp_flags@ */
923 Py_TPFLAGS_BASETYPE,
924
925 /* @tp_doc@ */
926 "Binary fields with normal basis representation.",
927
928 0, /* @tp_traverse@ */
929 0, /* @tp_clear@ */
930 field_pyrichcompare, /* @tp_richcompare@ */
931 0, /* @tp_weaklistoffset@ */
932 0, /* @tp_iter@ */
933 0, /* @tp_iternext@ */
934 0, /* @tp_methods@ */
935 0, /* @tp_members@ */
936 binnormfield_pygetset, /* @tp_getset@ */
937 0, /* @tp_base@ */
938 0, /* @tp_dict@ */
939 0, /* @tp_descr_get@ */
940 0, /* @tp_descr_set@ */
941 0, /* @tp_dictoffset@ */
942 0, /* @tp_init@ */
943 PyType_GenericAlloc, /* @tp_alloc@ */
944 binnormfield_pynew, /* @tp_new@ */
945 0, /* @tp_free@ */
946 0 /* @tp_is_gc@ */
947 };
948
949 /*----- Setup -------------------------------------------------------------*/
950
951 static PyObject *meth__Field_parse(PyObject *me, PyObject *arg)
952 {
953 field *f;
954 char *p;
955 PyObject *rc = 0;
956 qd_parse qd;
957
958 if (!PyArg_ParseTuple(arg, "Os:parse", &me, &p))
959 goto end;
960 qd.p = p;
961 qd.e = 0;
962 if ((f = field_parse(&qd)) == 0)
963 VALERR(qd.e);
964 rc = Py_BuildValue("(Ns)", field_pywrap(f), qd.p);
965 end:
966 return (rc);
967 }
968
969 static PyMethodDef methods[] = {
970 #define METHNAME(func) meth_##func
971 METH (_Field_parse, "parse(STR) -> F, REST")
972 #undef METHNAME
973 { 0 }
974 };
975
976 void field_pyinit(void)
977 {
978 INITTYPE(fe, root);
979 INITTYPE(field, type);
980 INITTYPE(primefield, field);
981 INITTYPE(niceprimefield, primefield);
982 INITTYPE(binfield, field);
983 INITTYPE(binpolyfield, binfield);
984 INITTYPE(binnormfield, binfield);
985 addmethods(methods);
986 }
987
988 void field_pyinsert(PyObject *mod)
989 {
990 INSERT("FE", fe_pytype);
991 INSERT("Field", field_pytype);
992 INSERT("PrimeField", primefield_pytype);
993 INSERT("NicePrimeField", niceprimefield_pytype);
994 INSERT("BinField", binfield_pytype);
995 INSERT("BinPolyField", binpolyfield_pytype);
996 INSERT("BinNormField", binnormfield_pytype);
997 }
998
999 /*----- That's all, folks -------------------------------------------------*/
Catacomb cryptographic library -- Python bindings