# -*-fundamental-*-
#
# $Id$
#
# Prime generation gubbins
#
# (c) 2001 Straylight/Edgeware
#

#----- Licensing notice -----------------------------------------------------
#
# This file is part of the Perl interface to Catacomb.
#
# Catacomb/Perl is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# Catacomb/Perl is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Catacomb/Perl; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Filter

MP_Prime_Filter *
new(me, x)
	SV *me
	mp *x
	CODE:
	RETVAL = CREATE(MP_Prime_Filter);
	RETVAL->rc = pfilt_create(&RETVAL->pf, x);
	OUTPUT:
	RETVAL

SV *
DESTROY(pf)
	MP_Prime_Filter *pf
	CODE:
	pfilt_destroy(&pf->pf);
	DESTROY(pf);
	XSRETURN_UNDEF;

int
status(pf)
	MP_Prime_Filter *pf
	CODE:
	RETVAL = pf->rc;
	OUTPUT:
	RETVAL

MP_Prime_Filter *
muladd(pf, m, a)
	MP_Prime_Filter *pf
	U32 m
	U32 a
	CODE:
	if (m > MPW_MAX)
	  croak("multiplier too large");
	if (a > MPW_MAX)
	  croak("step too large");
	RETVAL = CREATE(MP_Prime_Filter);
	RETVAL->rc = pfilt_muladd(&RETVAL->pf, &pf->pf, m, a);
	OUTPUT:
	RETVAL

int
step(pf, n)
	MP_Prime_Filter *pf
	U32 n
	CODE:
	if (n > MPW_MAX)
	  croak("step too large");
	RETVAL = pf->rc = pfilt_step(&pf->pf, n);
	OUTPUT:
	RETVAL

int
jump(pf, j)
	MP_Prime_Filter *pf
	MP_Prime_Filter *j
	CODE:
	RETVAL = pf->rc = pfilt_jump(&pf->pf, &j->pf);
	OUTPUT:
	RETVAL

mp *
m(pf)
	MP_Prime_Filter *pf
	CODE:
	RETVAL = mp_copy(pf->pf.m);
	OUTPUT:
	RETVAL

MP_Prime_Gen_FilterStepper *
stepper(me, step)
	SV *me
	unsigned step
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_FilterStepper);
	RETVAL->f.step = step;
	RETVAL->mg.p = pgen_filter;
	RETVAL->mg.ctx = &RETVAL->f;
	OUTPUT:
	RETVAL

MP_Prime_Gen_JumpStepper *
jumper(me, j)
	SV *me
	mp *j
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_JumpStepper);
	pfilt_create(&RETVAL->pf, j);
	RETVAL->j.j = &RETVAL->pf;
	RETVAL->mg.p = pgen_jump;
	RETVAL->mg.ctx = &RETVAL->j;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Rabin PREFIX = rabin_

MP_Prime_Rabin *
new(me, x)
	SV *me
	mp *x
	CODE:
	RETVAL = CREATE(MP_Prime_Rabin);
	if (rabin_create(RETVAL, x)) {
	  DESTROY(RETVAL);
	  RETVAL = 0;
	}
	OUTPUT:
	RETVAL

SV *
DESTROY(r)
	MP_Prime_Rabin *r
	CODE:
	rabin_destroy(r);
	DESTROY(r);
	XSRETURN_UNDEF;

int
rabin_test(r, g)
	MP_Prime_Rabin *r
	mp *g

mp *
m(r)
	MP_Prime_Rabin *r
	CODE:
	RETVAL = MP_COPY(r->mm.m);
	OUTPUT:
	RETVAL

int
rabin_iters(r)
	MP_Prime_Rabin *r
	C_ARGS:
	mp_bits(r->mm.m)

int
ntests(me, bits)
	SV *me
	int bits
	CODE:
	RETVAL = rabin_iters(bits);
	OUTPUT:
	RETVAL

MP_Prime_Gen_RabinTester *
tester(me)
	SV *me
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_RabinTester);
	RETVAL->mg.p = pgen_test;
	RETVAL->mg.ctx = &RETVAL->r;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::MagicProc

SV *
DESTROY(proc)
	MP_Prime_Gen_MagicProc *proc
	CODE:
	DESTROY(proc);
	XSRETURN_UNDEF;

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::FilterStepper

SV *
DESTROY(s)
	MP_Prime_Gen_FilterStepper *s
	CODE:
	DESTROY(s);
	XSRETURN_UNDEF;

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::JumpStepper

SV *
DESTROY(s)
	MP_Prime_Gen_JumpStepper *s
	CODE:
	pfilt_destroy(&s->pf);
	DESTROY(s);
	XSRETURN_UNDEF;

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::RabinTester

SV *
DESTROY(t)
	MP_Prime_Gen_RabinTester *t
	CODE:
	DESTROY(t);
	XSRETURN_UNDEF;

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::Proc

MP_Prime_Gen_MagicProc *
ev(me)
	SV *me
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_MagicProc);
	RETVAL->p = pgen_ev;
	RETVAL->ctx = 0;
	OUTPUT:
	RETVAL

MP_Prime_Gen_MagicProc *
evspin(me)
	SV *me
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_MagicProc);
	RETVAL->p = pgen_evspin;
	RETVAL->ctx = 0;
	OUTPUT:
	RETVAL

MP_Prime_Gen_MagicProc *
subev(me)
	SV *me
	CODE:
	RETVAL = CREATE(MP_Prime_Gen_MagicProc);
	RETVAL->p = pgen_subev;
	RETVAL->ctx = 0;
	OUTPUT:
	RETVAL

int
PG_BEGIN(me, ev)
	SV *me
	MP_Prime_Gen_Event *ev
	ALIAS:
	PG_TRY = 0
	PG_PASS = 1
	PG_FAIL = 2
	PG_ABORT = 3
	PG_DONE = 4
	CODE:
	RETVAL = 0;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime

mp *
gen(me, name, m, steps, stepper, tests, tester, events = &PL_sv_undef)
	SV *me
	char *name
	mp *m
	MP_Prime_Gen_NullProc *events
	unsigned steps
	MP_Prime_Gen_Proc *stepper
	unsigned tests
	MP_Prime_Gen_Proc *tester
	PREINIT:
	pgen_proc *ev, *step, *test;
	void *ectx, *sctx, *tctx;
	CODE:
	pgproc_get(events, &ev, &ectx);
	pgproc_get(stepper, &step, &sctx);
	pgproc_get(tester, &test, &tctx);
	RETVAL = pgen(name, MP_NEW, m, ev, ectx,
		      steps, step, sctx, tests, test, tctx);
	OUTPUT:
	RETVAL

void
strongprime_setup(me, name, bits, r = &rand_global, n = 0, events = &PL_sv_undef)
	SV *me
	char *name
	unsigned bits
	grand *r
	unsigned n
	MP_Prime_Gen_NullProc *events
	PREINIT:
	pgen_proc *ev;
	void *ectx;
	mp *d;
	MP_Prime_Gen_JumpStepper *j;
	PPCODE:
	pgproc_get(events, &ev, &ectx);
	j = CREATE(MP_Prime_Gen_JumpStepper);
	d = strongprime_setup(name, MP_NEW, &j->pf, bits, r, n, ev, ectx);
	EXTEND(SP, 2);
	if (!d)
	  DESTROY(j);
	else {
	  j->j.j = &j->pf;
	  j->mg.p = pgen_jump;
	  j->mg.ctx = &j->j;
	  PUSHs(RET_MP(d));
	  PUSHs(RET(j, "Catacomb::MP::Prime::Gen::JumpStepper"));
	}

void
limlee(me, name, qbits, pbits, r = &rand_global, on = 0, oevents = &PL_sv_undef, ievents = &PL_sv_undef)
	SV *me
	char *name
	unsigned qbits
	unsigned pbits
	grand *r
	unsigned on
	MP_Prime_Gen_NullProc *oevents
	MP_Prime_Gen_NullProc *ievents
	PREINIT:
	pgen_proc *oev, *iev;
	void *oec, *iec;
	mp **f;
	size_t nf, i;
	mp *x;
	PPCODE:
	pgproc_get(oevents, &oev, &oec);
	pgproc_get(ievents, &iev, &iec);
	if (GIMME_V == G_SCALAR) {
	  x = limlee(name, MP_NEW, MP_NEW, qbits, pbits, r, on,
		     oev, oec, iev, iec, 0, 0);
	  if (!x) return;
	  EXTEND(SP, 1);
	  PUSHs(RET_MP(x));
	} else {
	  x = limlee(name, MP_NEW, MP_NEW, qbits, pbits, r, on,
		     oev, oec, iev, iec, &nf, &f);
	  if (!x) return;
	  EXTEND(SP, 1 + nf);
	  PUSHs(RET_MP(x));
	  for (i = 0; i < nf; i++)
	    PUSHs(RET_MP(f[i]));
	  xfree(f);
	}

MODULE = Catacomb PACKAGE = Catacomb::MP::Prime::Gen::Event

char *
name(ev)
	MP_Prime_Gen_Event *ev
	CODE:
	RETVAL = (char *)ev->name;
	OUTPUT:
	RETVAL

mp *
m(ev, x = &PL_sv_undef)
	MP_Prime_Gen_Event *ev
	SV *x
	PREINIT:
	mp *y;
	CODE:
	RETVAL = mp_copy(ev->m);
	if (SvOK(x)) {
	  if ((y = mp_fromsv(x, "x", 0, 1)) == 0)
	    croak("bad integer");
	  mp_drop(ev->m);
	  ev->m = y;
	}
	OUTPUT:
	RETVAL

int
steps(ev)
	MP_Prime_Gen_Event *ev
	CODE:
	RETVAL = ev->steps;
	OUTPUT:
	RETVAL

int
tests(ev)
	MP_Prime_Gen_Event *ev
	CODE:
	RETVAL = ev->tests;
	OUTPUT:
	RETVAL

SV *
rand(ev)
	MP_Prime_Gen_Event *ev
	CODE:
	RETVAL = MAKE(ev->r, "Catacomb::Rand::Magic");
	OUTPUT:
	RETVAL

#----- That's all, folks ----------------------------------------------------