diff options
| -rw-r--r-- | Include/mymalloc.h | 8 | ||||
| -rw-r--r-- | Modules/imageop.c | 134 | ||||
| -rw-r--r-- | Modules/md5module.c | 222 | ||||
| -rw-r--r-- | Modules/mpzmodule.c | 1808 | ||||
| -rw-r--r-- | Modules/socketmodule.c | 4 | ||||
| -rw-r--r-- | Python/ceval.c | 4 |
6 files changed, 2176 insertions, 4 deletions
diff --git a/Include/mymalloc.h b/Include/mymalloc.h index aadd0f3..e4315bd 100644 --- a/Include/mymalloc.h +++ b/Include/mymalloc.h @@ -53,12 +53,14 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. #define NULL 0 #endif -#define NEW(type, n) ( (type *) malloc((n) * sizeof(type)) ) +/* XXX Always allocate one extra byte, since some malloc's return NULL + XXX for malloc(0) or realloc(p, 0). */ +#define NEW(type, n) ( (type *) malloc(1 + (n) * sizeof(type)) ) #define RESIZE(p, type, n) \ if ((p) == NULL) \ - (p) = (type *) malloc((n) * sizeof(type)); \ + (p) = (type *) malloc(1 + (n) * sizeof(type)); \ else \ - (p) = (type *) realloc((ANY *)(p), (n) * sizeof(type)) + (p) = (type *) realloc((ANY *)(p), 1 + (n) * sizeof(type)) #define DEL(p) free((ANY *)p) #define XDEL(p) if ((p) == NULL) ; else DEL(p) diff --git a/Modules/imageop.c b/Modules/imageop.c index 8cd0128..c575c25 100644 --- a/Modules/imageop.c +++ b/Modules/imageop.c @@ -62,7 +62,8 @@ imageop_crop(self, args) xstep = (newx1 < newx2)? 1 : -1; ystep = (newy1 < newy2)? 1 : -1; - rv = newsizedstringobject(NULL, (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size); + rv = newsizedstringobject(NULL, + (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size); if ( rv == 0 ) return 0; ncp = (char *)getstringvalue(rv); @@ -123,6 +124,134 @@ imageop_scale(self, args) return rv; } +static object * +imageop_grey2mono(self, args) + object *self; + object *args; +{ + int tres, x, y, len; + unsigned char *cp, *ncp; + unsigned char ovalue; + object *rv; + int i, bit; + + + if ( !getargs(args, "(s#iii)", &cp, &len, &x, &y, &tres) ) + return 0; + + if ( x*y != len ) { + err_setstr(ImageopError, "String has incorrect length"); + return 0; + } + + rv = newsizedstringobject(NULL, (len+7)/8); + if ( rv == 0 ) + return 0; + ncp = (unsigned char *)getstringvalue(rv); + + bit = 0x80; + ovalue = 0; + for ( i=0; i < len; i++ ) { + if ( cp[i] > tres ) + ovalue |= bit; + bit >>= 1; + if ( bit == 0 ) { + *ncp++ = ovalue; + bit = 0x80; + ovalue = 0; + } + } + if ( bit != 0x80 ) + *ncp++ = ovalue; + return rv; +} + +static object * +imageop_dither2mono(self, args) + object *self; + object *args; +{ + int sum, x, y, len; + unsigned char *cp, *ncp; + unsigned char ovalue; + object *rv; + int i, bit; + + + if ( !getargs(args, "(s#ii)", &cp, &len, &x, &y) ) + return 0; + + if ( x*y != len ) { + err_setstr(ImageopError, "String has incorrect length"); + return 0; + } + + rv = newsizedstringobject(NULL, (len+7)/8); + if ( rv == 0 ) + return 0; + ncp = (unsigned char *)getstringvalue(rv); + + bit = 0x80; + ovalue = 0; + sum = 0; + for ( i=0; i < len; i++ ) { + sum += cp[i]; + if ( sum >= 256 ) { + sum -= 256; + ovalue |= bit; + } + bit >>= 1; + if ( bit == 0 ) { + *ncp++ = ovalue; + bit = 0x80; + ovalue = 0; + } + } + if ( bit != 0x80 ) + *ncp++ = ovalue; + return rv; +} + +static object * +imageop_mono2grey(self, args) + object *self; + object *args; +{ + int v0, v1, x, y, len, nlen; + unsigned char *cp, *ncp; + unsigned char ovalue; + object *rv; + int i, bit, value; + + if ( !getargs(args, "(s#iiii)", &cp, &len, &x, &y, &v0, &v1) ) + return 0; + + nlen = x*y; + if ( (nlen+7)/8 != len ) { + err_setstr(ImageopError, "String has incorrect length"); + return 0; + } + + rv = newsizedstringobject(NULL, nlen); + if ( rv == 0 ) + return 0; + ncp = (unsigned char *)getstringvalue(rv); + + bit = 0x80; + for ( i=0; i < nlen; i++ ) { + if ( *cp & bit ) + *ncp++ = v1; + else + *ncp++ = v0; + bit >>= 1; + if ( bit == 0 ) { + bit = 0x80; + cp++; + } + } + return rv; +} + /* static object * imageop_mul(self, args) @@ -161,6 +290,9 @@ imageop_mul(self, args) static struct methodlist imageop_methods[] = { { "crop", imageop_crop }, { "scale", imageop_scale }, + { "grey2mono", imageop_grey2mono }, + { "dither2mono", imageop_dither2mono }, + { "mono2grey", imageop_mono2grey }, { 0, 0 } }; diff --git a/Modules/md5module.c b/Modules/md5module.c new file mode 100644 index 0000000..3347067 --- /dev/null +++ b/Modules/md5module.c @@ -0,0 +1,222 @@ +/*********************************************************** +Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The +Netherlands. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ +/* MD5 module */ + +/* This module provides an interface to a message digest algorithm, + MD5 in this case */ + +/* MD5 objects */ + +#include "allobjects.h" +#include "modsupport.h" /* For getargs() etc. */ + +#include "md5.h" +typedef struct { + OB_HEAD + MD5_CTX md5; /* the context holder */ +} md5object; + +extern typeobject MD5type; /* Really static, forward */ + +#define is_md5object(v) ((v)->ob_type == &MD5type) + +static const char initialiser_name[] = "md5"; + +/* #define MD5_DEBUG */ + +static md5object * +newmd5object() +{ + md5object *md5p; + + +#ifdef MD5_DEBUG + fputs( "md5_object() called...\n", stderr ); +#endif /* def MD5_DEBUG */ + md5p = NEWOBJ(md5object, &MD5type); + if (md5p == NULL) + return NULL; + + MD5Init(&md5p->md5); /* actual initialisation */ + return md5p; +} /* newmd5object() */ + + +/* MD5 methods */ + +static void +md5_dealloc(md5p) + md5object *md5p; +{ +#ifdef MD5_DEBUG + fputs( "md5_dealloc() called...\n", stderr ); +#endif /* def MD5_DEBUG */ + + DEL(md5p); +} /* md5_dealloc() */ + + +/* MD5 initialisation */ + +static object * +MD5_md5(self, args) + object *self; + object *args; +{ + md5object *md5p; + char *cp = (char *)NULL; + int len; + + +#ifdef MD5_DEBUG + fputs("MD5_md5() called...\n", stderr); +#endif /* def MD5_DEBUG */ + + if (!getargs(args, "")) { + err_clear(); + if (!getargs(args, "s#", &cp, &len)) + return NULL; + } + + if ((md5p = newmd5object()) == NULL) + return NULL; + + if (cp) + MD5Update(&md5p->md5, cp, len); + + return (object *)md5p; +} /* MD5_md5() */ + + +/* MD5 methods-as-attributes */ +static object * +md5_update(self, args) + md5object *self; + object *args; +{ + char *cp; + int len; + + + if (!getargs(args, "s#", &cp, &len)) + return NULL; + + MD5Update(&self->md5, cp, len); + + INCREF(None); + return None; +} /* md5_update() */ + +static object * +md5_digest(self, args) + md5object *self; + object *args; +{ + MD5_CTX mdContext; + stringobject *strobjp; + + if (!getnoarg(args)) + return NULL; + + /* make a temporary copy, and perform the final */ + mdContext = self->md5; + MD5Final(&mdContext); + + return newsizedstringobject((char *)mdContext.digest, 16); +} /* md5_digest() */ + +static object * +md5_copy(self, args) + md5object *self; + object *args; +{ + md5object *md5p; + + + if (!getnoarg(args)) + return NULL; + + if ((md5p = newmd5object()) == NULL) + return NULL; + + md5p->md5 = self->md5; + + return (object *)md5p; +} /* md5_copy() */ + + +static struct methodlist md5_methods[] = { + {"update", md5_update}, + {"digest", md5_digest}, + {"copy", md5_copy}, + {NULL, NULL} /* sentinel */ +}; + +static object * +md5_getattr(self, name) + md5object *self; + char *name; +{ + return findmethod(md5_methods, (object *)self, name); +} /* md5_getattr() */ + + +static typeobject MD5type = { + OB_HEAD_INIT(&Typetype) + 0, /*ob_size*/ + "md5", /*tp_name*/ + sizeof(md5object), /*tp_size*/ + 0, /*tp_itemsize*/ + /* methods */ + md5_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + md5_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ +}; + +/* List of functions exported by this module */ + +static struct methodlist md5_functions[] = { + {initialiser_name, MD5_md5}, + {NULL, NULL} /* Sentinel */ +}; + + +/* Initialize this module. */ + +void +initmd5() +{ +#ifdef MD5_DEBUG + fputs( "initmd5() called...\n", stderr ); +#endif /* def MD5_DEBUG */ + (void)initmodule("md5", md5_functions); +} /* initmd5() */ + +#ifdef MAKEDUMMYINT +int _md5_dummy_int; /* XXX otherwise, we're .bss-less (DYNLOAD->Jack?) */ +#endif /* def MAKEDUMMYINT */ diff --git a/Modules/mpzmodule.c b/Modules/mpzmodule.c new file mode 100644 index 0000000..a3e903e --- /dev/null +++ b/Modules/mpzmodule.c @@ -0,0 +1,1808 @@ +/*********************************************************** +Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The +Netherlands. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ +/* MPZ module */ + +/* This module provides an interface to an alternate Multi-Precision + library, GNU MP in this case */ + +/* XXX note: everywhere where mpz_size is called, + sizeof (limb) == sizeof (long) has been assumed. */ + + +/* MPZ objects */ + +#include "allobjects.h" +#include "modsupport.h" /* For getargs() etc. */ +#include <assert.h> + +/* +** These are the cpp-flags used in this file... +** +** +** MPZ_MDIV_BUG works around the mpz_m{div,mod,...} routines. +** This bug has been fixed in a later release of +** GMP. +** +** MPZ_GET_STR_BUG mpz_get_str corrupts memory, seems to be fixed +** in a later release +** +** MPZ_DEBUG generates a bunch of diagnostic messages +** +** MPZ_SPARE_MALLOC if set, results in extra code that tries to +** minimize the creation of extra objects. +** +** MPZ_TEST_DIV extra diagnostic output on stderr, when division +** routines are involved +** +** MPZ_LIB_DOES_CHECKING if set, assumes that mpz library doesn't call +** alloca with arg < 0 (when casted to a signed +** integral type). +** +** MPZ_CONVERSIONS_AS_METHODS if set, presents the conversions as +** methods. e.g., `mpz(5).long() == 5L' +** Later, Guido provided an interface to the +** standard functions. So this flag has no been +** cleared, and `long(mpz(5)) == 5L' +** +** MP_TEST_ALLOC If set, you would discover why MPZ_GET_STR_BUG +** is needed +** +** MAKEDUMMYINT Must be set if dynamic linking will be used +*/ + + +/* +** IMHO, mpz_m{div,mod,divmod}() do the wrong things when the denominator < 0 +** I assume that this will be fixed in a future release +*/ +/*#define MPZ_MDIV_BUG fixed the (for me) nexessary parts in libgmp.a */ +/* +** IMO, mpz_get_str() assumes a bit too large target space, if he doesn't +** allocate it himself +*/ +#define MPZ_GET_STR_BUG + +#include "gmp.h" +typedef struct { + OB_HEAD + MP_INT mpz; /* the actual number */ +} mpzobject; + +extern typeobject MPZtype; /* Really static, forward */ + +#define is_mpzobject(v) ((v)->ob_type == &MPZtype) + +static const char initialiser_name[] = "mpz"; + +/* #define MPZ_DEBUG */ + +static mpzobject * +newmpzobject() +{ + mpzobject *mpzp; + + +#ifdef MPZ_DEBUG + fputs( "mpz_object() called...\n", stderr ); +#endif /* def MPZ_DEBUG */ + mpzp = NEWOBJ(mpzobject, &MPZtype); + if (mpzp == NULL) + return NULL; + + mpz_init(&mpzp->mpz); /* actual initialisation */ + return mpzp; +} /* newmpzobject() */ + +#ifdef MPZ_GET_STR_BUG +#include "gmp-impl.h" +#include "longlong.h" +#endif /* def MPZ_GET_STR_BUG */ + +static object * +mpz_format(objp, base, withname) + object *objp; + int base; + unsigned char withname; +{ + mpzobject *mpzp = (mpzobject *)objp; + stringobject *strobjp; + int i; + int cmpres; + int taglong; + char *cp; + char prefix[5], *tcp; + + + tcp = &prefix[0]; + + if (mpzp == NULL || !is_mpzobject(mpzp)) { + err_badcall(); + return NULL; + } + + assert(base >= 2 && base <= 36); + + if (withname) + i = strlen(initialiser_name) + 2; /* e.g. 'mpz(' + ')' */ + else + i = 0; + + if ((cmpres = mpz_cmp_si(&mpzp->mpz, 0L)) == 0) + base = 10; /* '0' in every base, right */ + else if (cmpres < 0) { + *tcp++ = '-'; + i += 1; /* space to hold '-' */ + } + +#ifdef MPZ_DEBUG + fprintf(stderr, "mpz_format: mpz_sizeinbase %d\n", + (int)mpz_sizeinbase(&mpzp->mpz, base)); +#endif /* def MPZ_DEBUG */ +#ifdef MPZ_GET_STR_BUG + i += ((size_t) abs(mpzp->mpz.size) * BITS_PER_MP_LIMB + * __mp_bases[base].chars_per_bit_exactly) + 1; +#else /* def MPZ_GET_STR_BUG */ + i += (int)mpz_sizeinbase(&mpzp->mpz, base); +#endif /* def MPZ_GET_STR_BUG else */ + + if (base == 16) { + *tcp++ = '0'; + *tcp++ = 'x'; + i += 2; /* space to hold '0x' */ + } + else if (base == 8) { + *tcp++ = '0'; + i += 1; /* space to hold the extra '0' */ + } + else if (base > 10) { + *tcp++ = '0' + base / 10; + *tcp++ = '0' + base % 10; + *tcp++ = '#'; + i += 3; /* space to hold e.g. '12#' */ + } + else if (base < 10) { + *tcp++ = '0' + base; + *tcp++ = '#'; + i += 2; /* space to hold e.g. '6#' */ + } + + /* + ** the following code looks if we need a 'L' attached to the number + ** it will also attach an 'L' to the value -0x80000000 + */ + taglong = 0; + if (mpz_size(&mpzp->mpz) > 1 + || (long)mpz_get_ui(&mpzp->mpz) < 0L) { + taglong = 1; + i += 1; /* space to hold 'L' */ + } + +#ifdef MPZ_DEBUG + fprintf(stderr, "mpz_format: requesting string size %d\n", i); +#endif /* def MPZ_DEBUG */ + if ((strobjp = (stringobject *)newsizedstringobject((char *)0, i)) + == NULL) + return NULL; + + /* get the beginning of the string memory and start copying things */ + cp = GETSTRINGVALUE(strobjp); + if (withname) { + strcpy(cp, initialiser_name); + cp += strlen(initialiser_name); + *cp++ = '('; /*')'*/ + } + + /* copy the already prepared prefix; e.g. sign and base indicator */ + *tcp = '\0'; + strcpy(cp, prefix); + cp += tcp - prefix; + + /* since' we have the sign already, let the lib think it's a positive + number */ + if (cmpres < 0) + mpz_neg(&mpzp->mpz,&mpzp->mpz); /* hack Hack HAck HACk HACK */ + (void)mpz_get_str(cp, base, &mpzp->mpz); + if (cmpres < 0) + mpz_neg(&mpzp->mpz,&mpzp->mpz); /* hack Hack HAck HACk HACK */ +#ifdef MPZ_DEBUG + fprintf(stderr, "mpz_format: base (ultim) %d, mpz_get_str: %s\n", + base, cp); +#endif /* def MPZ_DEBUG */ + cp += strlen(cp); + + if (taglong) + *cp++ = 'L'; + if (withname) + *cp++ = /*'('*/ ')'; + + *cp = '\0'; + +#ifdef MPZ_DEBUG + fprintf(stderr, + "mpz_format: cp (str end) 0x%x, begin 0x%x, diff %d, i %d\n", + cp, GETSTRINGVALUE(strobjp), cp - GETSTRINGVALUE(strobjp), i); +#endif /* def MPZ_DEBUG */ + assert(cp - GETSTRINGVALUE(strobjp) <= i); + + if (cp - GETSTRINGVALUE(strobjp) != i) { + strobjp->ob_size -= i - (cp - GETSTRINGVALUE(strobjp)); + } + + return (object *)strobjp; +} /* mpz_format() */ + +/* MPZ methods */ + +static void +mpz_dealloc(mpzp) + mpzobject *mpzp; +{ +#ifdef MPZ_DEBUG + fputs( "mpz_dealloc() called...\n", stderr ); +#endif /* def MPZ_DEBUG */ + mpz_clear(&mpzp->mpz); + DEL(mpzp); +} /* mpz_dealloc() */ + +/* ARGSUSED */ +static int +mpz_print(v, fp, flags) + object *v; + FILE *fp; + int flags; /* Not used but required by interface */ +{ + stringobject *str + = (stringobject *)mpz_format(v, 10, (unsigned char)1); + + if (str == NULL) + return -1; + + fputs(GETSTRINGVALUE(str), fp); + DECREF(str); + return 0; +} /* mpz_print() */ + + +/* pointers to frequently used values 0, 1 and -1 */ +static mpzobject *mpz_value_zero, *mpz_value_one, *mpz_value_mone; + +static int +mpz_compare(a, b) + mpzobject *a, *b; +{ + int cmpres; + + + /* guido sez it's better to return -1, 0 or 1 */ + return (cmpres = mpz_cmp( &a->mpz, &b->mpz )) == 0 ? 0 + : cmpres > 0 ? 1 : -1; +} /* mpz_compare() */ + +static object * +mpz_addition(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + + +#ifdef MPZ_SPARE_MALLOC + if (mpz_cmp_ui(&a->mpz, (unsigned long int)0) == 0) { + INCREF(b); + return (object *)b; + } + + if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) { + INCREF(a); + return (object *)a; + } +#endif /* def MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_add(&z->mpz, &a->mpz, &b->mpz); + return (object *)z; +} /* mpz_addition() */ + +static object * +mpz_substract(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + + +#ifdef MPZ_SPARE_MALLOC + if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) { + INCREF(a); + return (object *)a; + } +#endif /* MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_sub(&z->mpz, &a->mpz, &b->mpz); + return (object *)z; +} /* mpz_substract() */ + +static object * +mpz_multiply(a, b) + mpzobject *a; + mpzobject *b; +{ +#ifdef MPZ_SPARE_MALLOC + int cmpres; +#endif /* def MPZ_SPARE_MALLOC */ + mpzobject *z; + + +#ifdef MPZ_SPARE_MALLOC + if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) { + INCREF(mpz_value_zero); + return (object *)mpz_value_zero; + } + if (cmpres > 0 && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) { + INCREF(b); + return (object *)b; + } + + if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long_int)0)) == 0) { + INCREF(mpz_value_zero); + return (object *)mpz_value_zero; + } + if (cmpres > 0 && mpz_cmp_ui(&b->mpz, (unsigned long int)1) == 0) { + INCREF(a); + return (object *)a; + } +#endif /* MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_mul( &z->mpz, &a->mpz, &b->mpz ); + return (object *)z; + +} /* mpz_multiply() */ + +static object * +mpz_divide(a, b) + mpzobject *a; + mpzobject *b; +{ +#ifdef MPZ_SPARE_MALLOC + int cmpres; +#endif /* def MPZ_SPARE_MALLOC */ + mpzobject *z; + + + if (( +#ifdef MPZ_SPARE_MALLOC + cmpres = +#endif /* def MPZ_SPARE_MALLOC */ + mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) { + err_setstr(ZeroDivisionError, "mpz./ by zero"); + return NULL; + } +#ifdef MPZ_SPARE_MALLOC + if (cmpres > 0 && mpz_cmp_ui(&b->mpz(unsigned long int)1) == 0) { + INCREF(a); + return (object *)a; + } +#endif /* def MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + +#ifdef MPZ_TEST_DIV + fputs("mpz_divide: div result", stderr); + mpz_div(&z->mpz, &a->mpz, &b->mpz); + mpz_out_str(stderr, 10, &z->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ +#ifdef MPZ_MDIV_BUG + if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0) + != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0)) { + /* + ** numerator has other sign than denominator: we have + ** to look at the remainder for a correction, since mpz_mdiv + ** also calls mpz_divmod, I can as well do it myself + */ + MP_INT tmpmpz; + + + mpz_init(&tmpmpz); + mpz_divmod(&z->mpz, &tmpmpz, &a->mpz, &b->mpz); + + if (mpz_cmp_ui(&tmpmpz, (unsigned long int)0) != 0) + mpz_sub_ui(&z->mpz, &z->mpz, (unsigned long int)1); + + mpz_clear(&tmpmpz); + } + else + mpz_div(&z->mpz, &a->mpz, &b->mpz); + /* the ``naive'' implementation does it right for operands + having the same sign */ + +#else /* def MPZ_MDIV_BUG */ + mpz_mdiv(&z->mpz, &a->mpz, &b->mpz); +#endif /* def MPZ_MDIV_BUG else */ +#ifdef MPZ_TEST_DIV + fputs("mpz_divide: mdiv result", stderr); + mpz_out_str(stderr, 10, &z->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ + return (object *)z; + +} /* mpz_divide() */ + +static object * +mpz_remainder(a, b) + mpzobject *a; + mpzobject *b; +{ +#ifdef MPZ_SPARE_MALLOC + int cmpres; +#endif /* def MPZ_SPARE_MALLOC */ + mpzobject *z; + + + if (( +#ifdef MPZ_SPARE_MALLOC + cmpres = +#endif /* def MPZ_SPARE_MALLOC */ + mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) { + err_setstr(ZeroDivisionError, "mpz.% by zero"); + return NULL; + } +#ifdef MPZ_SPARE_MALLOC + if (cmpres > 0) { + if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)2)) == 0) { + INCREF(mpz_value_one); + return (object *)mpz_value_one; + } + if (cmpres < 0) { + /* b must be 1 now */ + INCREF(mpz_value_zero); + return (object *)mpz_value_zero; + } + } +#endif /* def MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + +#ifdef MPZ_TEST_DIV + fputs("mpz_remain: mod result", stderr); + mpz_mod(&z->mpz, &a->mpz, &b->mpz); + mpz_out_str(stderr, 10, &z->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ +#ifdef MPZ_MDIV_BUG + + /* the ``naive'' implementation does it right for operands + having the same sign */ + mpz_mod(&z->mpz, &a->mpz, &b->mpz); + + /* assumption: z, a and b all point to different locations */ + if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0) + != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0) + && mpz_cmp_ui(&z->mpz, (unsigned long int)0) != 0) + mpz_add(&z->mpz, &z->mpz, &b->mpz); + /* + ** numerator has other sign than denominator: we have + ** to look at the remainder for a correction, since mpz_mdiv + ** also calls mpz_divmod, I can as well do it myself + */ +#else /* def MPZ_MDIV_BUG */ + mpz_mmod(&z->mpz, &a->mpz, &b->mpz); +#endif /* def MPZ_MDIV_BUG else */ +#ifdef MPZ_TEST_DIV + fputs("mpz_remain: mmod result", stderr); + mpz_out_str(stderr, 10, &z->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ + return (object *)z; + +} /* mpz_remainder() */ + +static object * +mpz_div_and_mod(a, b) + mpzobject *a; + mpzobject *b; +{ + object *z = NULL; + mpzobject *x = NULL, *y = NULL; + + + if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) { + err_setstr(ZeroDivisionError, "mpz.divmod by zero"); + return NULL; + } + + if ((z = newtupleobject(2)) == NULL + || (x = newmpzobject()) == NULL + || (y = newmpzobject()) == NULL) { + XDECREF(z); + XDECREF(x); + XDECREF(y); + return NULL; + } + +#ifdef MPZ_TEST_DIV + fputs("mpz_divmod: dm result", stderr); + mpz_divmod(&x->mpz, &y->mpz, &a->mpz, &b->mpz); + mpz_out_str(stderr, 10, &x->mpz); + putc('\n', stderr); + mpz_out_str(stderr, 10, &y->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ +#ifdef MPZ_MDIV_BUG + mpz_divmod(&x->mpz, &y->mpz, &a->mpz, &b->mpz); + if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0) + != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0) + && mpz_cmp_ui(&y->mpz, (unsigned long int)0) != 0) { + /* + ** numerator has other sign than denominator: we have + ** to look at the remainder for a correction. + */ + mpz_add(&y->mpz, &y->mpz, &b->mpz); + mpz_sub_ui(&x->mpz, &x->mpz, (unsigned long int)1); + } +#else /* def MPZ_MDIV_BUG */ + mpz_mdivmod( &x->mpz, &y->mpz, &a->mpz, &b->mpz ); +#endif /* def MPZ_MDIV_BUG else */ +#ifdef MPZ_TEST_DIV + fputs("mpz_divmod: mdm result", stderr); + mpz_out_str(stderr, 10, &x->mpz); + putc('\n', stderr); + mpz_out_str(stderr, 10, &y->mpz); + putc('\n', stderr); +#endif /* def MPZ_TEST_DIV */ + + (void)settupleitem(z, 0, (object *)x); + (void)settupleitem(z, 1, (object *)y); + + return z; +} /* mpz_div_and_mod() */ + +static object * +mpz_power(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + int cmpres; + long int longtmp1, longtmp2; + + + if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) { + /* the gnu-mp lib sets pow(0,0) to 0, we to 1 */ + + INCREF(mpz_value_one); + return (object *)mpz_value_one; + } + + if (cmpres < 0) { + err_setstr(ValueError, "mpz.pow to negative exponent"); + return NULL; + } + + if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) { + /* the base is 0 */ + + INCREF(mpz_value_zero); + return (object *)mpz_value_zero; + } + else if (cmpres > 0 + && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) { + /* the base is 1 */ + + INCREF(mpz_value_one); + return (object *)mpz_value_one; + } + else if (cmpres < 0 + && mpz_cmp_si(&a->mpz, (long int)-1) == 0) { + + MP_INT tmpmpz; + /* the base is -1: pow(-1, any) == 1,-1 for even,uneven b */ + /* XXX this code needs to be optimized: what's better? + mpz_mmod_ui or mpz_mod_2exp, I choose for the latter + for *un*obvious reasons */ + + /* is the exponent even? */ + mpz_init(&tmpmpz); + + /* look to the remainder after a division by (1 << 1) */ + mpz_mod_2exp(&tmpmpz, &b->mpz, (unsigned long int)1); + + if (mpz_cmp_ui(&tmpmpz, (unsigned int)0) == 0) { + mpz_clear(&tmpmpz); + INCREF(mpz_value_one); + return (object *)mpz_value_one; + } + mpz_clear(&tmpmpz); + INCREF(mpz_value_mone); + return (object *)mpz_value_mone; + } + +#ifdef MPZ_LIB_DOES_CHECKING + /* check if it's doable: sizeof(exp) > sizeof(long) && + abs(base) > 1 ?? --> No Way */ + if (mpz_size(&b->mpz) > 1) + return (object *)err_nomem(); +#else /* def MPZ_LIB_DOES_CHECKING */ + /* wet finger method */ + if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) { + err_setstr(ValueError, "mpz.pow outrageous exponent"); + return NULL; + } +#endif /* def MPZ_LIB_DOES_CHECKING else */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_pow_ui(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz)); + + return (object *)z; +} /* mpz_power() */ + + +static object * +mpz_negative(v) + mpzobject *v; +{ + mpzobject *z; + + +#ifdef MPZ_SPARE_MALLOC + if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) == 0) { + /* -0 == 0 */ + INCREF(v); + return (object *)v; + } +#endif /* def MPZ_SPARE_MALLOC */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_neg(&z->mpz, &v->mpz); + return (object *)z; +} /* mpz_negative() */ + + +static object * +mpz_positive(v) + mpzobject *v; +{ + INCREF(v); + return (object *)v; +} /* mpz_positive() */ + + +static object * +mpz_absolute(v) + mpzobject *v; +{ + mpzobject *z; + + + if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) >= 0) { + INCREF(v); + return (object *)v; + } + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_neg(&z->mpz, &v->mpz); + return (object *)z; +} /* mpz_absolute() */ + +static int +mpz_nonzero(v) + mpzobject *v; +{ + return mpz_cmp_ui(&v->mpz, (unsigned long int)0) != 0; +} /* mpz_nonzero() */ + +static object * +mpz_invert(v) + mpzobject *v; +{ + mpzobject *z; + + + /* I think mpz_com does exactly what needed */ + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_com(&z->mpz, &v->mpz); + return (object *)z; +} /* mpz_invert() */ + +static object * +mpz_lshift(a, b) + mpzobject *a; + mpzobject *b; +{ + int cmpres; + mpzobject *z; + + + if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) { + /* a << 0 == a */ + INCREF(a); + return (object *)a; + } + + if (cmpres < 0) { + err_setstr(ValueError, "mpz.<< negative shift count"); + return NULL; + } + +#ifdef MPZ_LIB_DOES_CHECKING + if (mpz_size(&b->mpz) > 1) + return (object *)err_nomem(); +#else /* def MPZ_LIB_DOES_CHECKING */ + /* wet finger method */ + if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) { + err_setstr(ValueError, "mpz.<< outrageous shift count"); + return NULL; + } +#endif /* def MPZ_LIB_DOES_CHECKING else */ + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_mul_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz)); + return (object *)z; +} /* mpz_lshift() */ + +static object * +mpz_rshift(a, b) + mpzobject *a; + mpzobject *b; +{ + int cmpres; + mpzobject *z; + + + if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) { + /* a >> 0 == a */ + INCREF(a); + return (object *)a; + } + + if (cmpres < 0) { + err_setstr(ValueError, "mpz.>> negative shift count"); + return NULL; + } + + if (mpz_size(&b->mpz) > 1) + return (object *)err_nomem(); + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_div_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz)); + return (object *)z; +} /* mpz_rshift() */ + +static object * +mpz_andfunc(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_and(&z->mpz, &a->mpz, &b->mpz); + return (object *)z; +} /* mpz_andfunc() */ + +/* hack Hack HAck HACk HACK, XXX this code is dead slow */ +void +mpz_xor(res, op1, op2) + MP_INT *res; + const MP_INT *op1; + const MP_INT *op2; +{ + MP_INT tmpmpz; + + mpz_init(&tmpmpz); + + mpz_and(res, op1, op2); + mpz_com(&tmpmpz, res); + mpz_ior(res, op1, op2); + mpz_and(res, res, &tmpmpz); + + mpz_clear(&tmpmpz); +} /* mpz_xor() HACK */ + +static object * +mpz_xorfunc(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_xor(&z->mpz, &a->mpz, &b->mpz); + return (object *)z; +} /* mpz_xorfunc() */ + +static object * +mpz_orfunc(a, b) + mpzobject *a; + mpzobject *b; +{ + mpzobject *z; + + + if ((z = newmpzobject()) == NULL) + return NULL; + + mpz_ior(&z->mpz, &a->mpz, &b->mpz); + return (object *)z; +} /* mpz_orfunc() */ + +/* MPZ initialisation */ + +#include "longintrepr.h" + +static object * +MPZ_mpz(self, args) + object *self; + object *args; +{ + mpzobject *mpzp; + object *objp; + + +#ifdef MPZ_DEBUG + fputs("MPZ_mpz() called...\n", stderr); +#endif /* def MPZ_DEBUG */ + + if (!getargs(args, "O", &objp)) + return NULL; + + /* at least we know it's some object */ + /* note DON't DECREF args NEITHER objp */ + + if (is_intobject(objp)) { + long lval; + + if (!getargs(objp, "l", &lval)) + return NULL; + + if (lval == (long)0) { + INCREF(mpz_value_zero); + mpzp = mpz_value_zero; + } + else if (lval == (long)1) { + INCREF(mpz_value_one); + mpzp = mpz_value_one; + } + else if ((mpzp = newmpzobject()) == NULL) + return NULL; + else mpz_set_si(&mpzp->mpz, lval); + } + else if (is_longobject(objp)) { + MP_INT mplongdigit; + int i; + unsigned char isnegative; + + + if ((mpzp = newmpzobject()) == NULL) + return NULL; + + mpz_set_si(&mpzp->mpz, 0L); + mpz_init(&mplongdigit); + + /* how we're gonna handle this? */ + if (isnegative = ((i = ((longobject *)objp)->ob_size) < 0) ) + i = -i; + + while (i--) { + mpz_set_ui(&mplongdigit, + (unsigned long) + ((longobject *)objp)->ob_digit[i]); + mpz_mul_2exp(&mplongdigit,&mplongdigit, + (unsigned long int)i * SHIFT); + mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit); + } + + if (isnegative) + mpz_neg(&mpzp->mpz, &mpzp->mpz); + + /* get rid of allocation for tmp variable */ + mpz_clear(&mplongdigit); + } + else if (is_stringobject(objp)) { + char *cp; + int len; + MP_INT mplongdigit; + + if (!getargs(objp, "s#", &cp, &len)) + return NULL; + + if ((mpzp = newmpzobject()) == NULL) + return NULL; + + mpz_set_si(&mpzp->mpz, 0L); + mpz_init(&mplongdigit); + + /* let's do it the same way as with the long conversion: + without thinking how it can be faster (-: :-) */ + + cp += len; + while (len--) { + mpz_set_ui(&mplongdigit, (unsigned long)*--cp ); + mpz_mul_2exp(&mplongdigit,&mplongdigit, + (unsigned long int)len * 8); + mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit); + } + + /* get rid of allocation for tmp variable */ + mpz_clear(&mplongdigit); + } + else if (is_mpzobject(objp)) { + INCREF(objp); + mpzp = (mpzobject *)objp; + } + else { + err_setstr(TypeError, + "mpz.mpz() expects integer, long, string or mpz object argument"); + return NULL; + } + + +#ifdef MPZ_DEBUG + fputs("MPZ_mpz: created mpz=", stderr); + mpz_out_str(stderr, 10, &mpzp->mpz); + putc('\n', stderr); +#endif /* def MPZ_DEBUG */ + return (object *)mpzp; +} /* MPZ_mpz() */ + +static mpzobject * +mpz_mpzcoerce(z) + object *z; +{ + /* shortcut: 9 out of 10 times the type is already ok */ + if (is_mpzobject(z)) { + INCREF(z); + return (mpzobject *)z; /* coercion succeeded */ + } + + /* what types do we accept?: intobjects and longobjects */ + if (is_intobject(z) || is_longobject(z)) + return (mpzobject *)MPZ_mpz((object *)NULL, z); + + err_setstr(TypeError, "number coercion (to mpzobject) failed"); + return NULL; +} /* mpz_mpzcoerce() */ + +static object * +MPZ_powm(self, args) + object *self; + object *args; +{ + object *base, *exp, *mod; + mpzobject *mpzbase = NULL, *mpzexp = NULL, *mpzmod = NULL; + mpzobject *z; + int tstres; + + + if (!getargs(args, "(OOO)", &base, &exp, &mod)) + return NULL; + + if ((mpzbase = mpz_mpzcoerce(base)) == NULL + || (mpzexp = mpz_mpzcoerce(exp)) == NULL + || (mpzmod = mpz_mpzcoerce(mod)) == NULL + || (z = newmpzobject()) == NULL) { + XDECREF(mpzbase); + XDECREF(mpzexp); + XDECREF(mpzmod); + return NULL; + } + + if ((tstres=mpz_cmp_ui(&mpzexp->mpz, (unsigned long int)0)) == 0) { + INCREF(mpz_value_one); + return (object *)mpz_value_one; + } + + if (tstres < 0) { + MP_INT absexp; + /* negative exp */ + + mpz_init_set(&absexp, &mpzexp->mpz); + mpz_abs(&absexp, &absexp); + mpz_powm(&z->mpz, &mpzbase->mpz, &absexp, &mpzmod->mpz); + + mpz_divm(&z->mpz, &mpz_value_one->mpz, &z->mpz, &mpzmod->mpz); + + mpz_clear(&absexp); + } + else { + mpz_powm(&z->mpz, &mpzbase->mpz, &mpzexp->mpz, &mpzmod->mpz); + } + + DECREF(mpzbase); + DECREF(mpzexp); + DECREF(mpzmod); + + return (object *)z; +} /* MPZ_powm() */ + + +static object * +MPZ_gcd(self, args) + object *self; + object *args; +{ + object *op1, *op2; + mpzobject *mpzop1 = NULL, *mpzop2 = NULL; + mpzobject *z; + + + if (!getargs(args, "(OO)", &op1, &op2)) + return NULL; + + if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL + || (mpzop2 = mpz_mpzcoerce(op2)) == NULL + || (z = newmpzobject()) == NULL) { + XDECREF(mpzop1); + XDECREF(mpzop2); + return NULL; + } + + /* ok, we have three mpzobjects, and an initialised result holder */ + mpz_gcd(&z->mpz, &mpzop1->mpz, &mpzop2->mpz); + + DECREF(mpzop1); + DECREF(mpzop2); + + return (object *)z; +} /* MPZ_gcd() */ + + +static object * +MPZ_gcdext(self, args) + object *self; + object *args; +{ + object *op1, *op2, *z = NULL; + mpzobject *mpzop1 = NULL, *mpzop2 = NULL; + mpzobject *g = NULL, *s = NULL, *t = NULL; + + + if (!getargs(args, "(OO)", &op1, &op2)) + return NULL; + + if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL + || (mpzop2 = mpz_mpzcoerce(op2)) == NULL + || (z = newtupleobject(3)) == NULL + || (g = newmpzobject()) == NULL + || (s = newmpzobject()) == NULL + || (t = newmpzobject()) == NULL) { + XDECREF(mpzop1); + XDECREF(mpzop2); + XDECREF(z); + XDECREF(g); + XDECREF(s); + /*XDECREF(t);*/ + return NULL; + } + + mpz_gcdext(&g->mpz, &s->mpz, &t->mpz, &mpzop1->mpz, &mpzop2->mpz); + + DECREF(mpzop1); + DECREF(mpzop2); + + (void)settupleitem(z, 0, (object *)g); + (void)settupleitem(z, 1, (object *)s); + (void)settupleitem(z, 2, (object *)t); + + return (object *)z; +} /* MPZ_gcdext() */ + + +static object * +MPZ_sqrt(self, args) + object *self; + object *args; +{ + object *op; + mpzobject *mpzop = NULL; + mpzobject *z; + + + if (!getargs(args, "O", &op)) + return NULL; + + if ((mpzop = mpz_mpzcoerce(op)) == NULL + || (z = newmpzobject()) == NULL) { + XDECREF(mpzop); + return NULL; + } + + mpz_sqrt(&z->mpz, &mpzop->mpz); + + DECREF(mpzop); + + return (object *)z; +} /* MPZ_sqrt() */ + + +static object * +MPZ_sqrtrem(self, args) + object *self; + object *args; +{ + object *op, *z = NULL; + mpzobject *mpzop = NULL; + mpzobject *root = NULL, *rem = NULL; + + + if (!getargs(args, "O", &op)) + return NULL; + + if ((mpzop = mpz_mpzcoerce(op)) == NULL + || (z = newtupleobject(2)) == NULL + || (root = newmpzobject()) == NULL + || (rem = newmpzobject()) == NULL) { + XDECREF(mpzop); + XDECREF(z); + XDECREF(root); + /*XDECREF(rem);*/ + return NULL; + } + + mpz_sqrtrem(&root->mpz, &rem->mpz, &mpzop->mpz); + + DECREF(mpzop); + + (void)settupleitem(z, 0, (object *)root); + (void)settupleitem(z, 1, (object *)rem); + + return (object *)z; +} /* MPZ_sqrtrem() */ + + +void +#if __STDC__ +mpz_divm(MP_INT *res, const MP_INT *num, const MP_INT *den, const MP_INT *mod) +#else +mpz_divm(res, num, den, mod) + MP_INT *res; + const MP_INT *num; + const MP_INT *den; + const MP_INT *mod; +#endif +{ + MP_INT s0, s1, q, r, x, d0, d1; + + mpz_init_set(&s0, num); + mpz_init_set_ui(&s1, 0); + mpz_init(&q); + mpz_init(&r); + mpz_init(&x); + mpz_init_set(&d0, den); + mpz_init_set(&d1, mod); + + while (d1.size != 0) { + mpz_divmod(&q, &r, &d0, &d1); + mpz_set(&d0, &d1); + mpz_set(&d1, &r); + + mpz_mul(&x, &s1, &q); + mpz_sub(&x, &s0, &x); + mpz_set(&s0, &s1); + mpz_set(&s1, &x); + } + + if (d0.size != 1 || d0.d[0] != 1) + res->size = 0; /* trouble: the gcd != 1; set s to zero */ + else { +#ifdef MPZ_MDIV_BUG + /* watch out here! first check the signs, and then perform + the mpz_mod() since mod could point to res */ + if ((s0.size < 0) != (mod->size < 0)) { + mpz_mod(res, &s0, mod); + + if (res->size) + mpz_add(res, res, mod); + } + else + mpz_mod(res, &s0, mod); + +#else /* def MPZ_MDIV_BUG */ + mpz_mmod(res, &s0, mod); +#endif /* def MPZ_MDIV_BUG else */ + } + + mpz_clear(&s0); + mpz_clear(&s1); + mpz_clear(&q); + mpz_clear(&r); + mpz_clear(&x); + mpz_clear(&d0); + mpz_clear(&d1); +} /* mpz_divm() */ + + +static object * +MPZ_divm(self, args) + object *self; + object *args; +{ + object *num, *den, *mod; + mpzobject *mpznum, *mpzden, *mpzmod = NULL; + mpzobject *z = NULL; + + + if (!getargs(args, "(OOO)", &num, &den, &mod)) + return NULL; + + if ((mpznum = mpz_mpzcoerce(num)) == NULL + || (mpzden = mpz_mpzcoerce(den)) == NULL + || (mpzmod = mpz_mpzcoerce(mod)) == NULL + || (z = newmpzobject()) == NULL ) { + XDECREF(mpznum); + XDECREF(mpzden); + XDECREF(mpzmod); + return NULL; + } + + mpz_divm(&z->mpz, &mpznum->mpz, &mpzden->mpz, &mpzmod->mpz); + + DECREF(mpznum); + DECREF(mpzden); + DECREF(mpzmod); + + if (mpz_cmp_ui(&z->mpz, (unsigned long int)0) == 0) { + DECREF(z); + err_setstr(ValueError, "gcd(den, mod) != 1 or num == 0"); + return NULL; + } + + return (object *)z; +} /* MPZ_divm() */ + + +/* MPZ methods-as-attributes */ +#ifdef MPZ_CONVERSIONS_AS_METHODS +static object * +mpz_int(self, args) + mpzobject *self; + object *args; +#else /* def MPZ_CONVERSIONS_AS_METHODS */ +static object * +mpz_int(self) + mpzobject *self; +#endif /* def MPZ_CONVERSIONS_AS_METHODS else */ +{ + long sli; + + +#ifdef MPZ_CONVERSIONS_AS_METHODS + if (!getnoarg(args)) + return NULL; +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + + if (mpz_size(&self->mpz) > 1 + || (sli = (long)mpz_get_ui(&self->mpz)) < (long)0 ) { + err_setstr(ValueError, "mpz.int() arg too long to convert"); + return NULL; + } + + if (mpz_cmp_ui(&self->mpz, (unsigned long)0) < 0) + sli = -sli; + + return newintobject(sli); +} /* mpz_int() */ + +static object * +#ifdef MPZ_CONVERSIONS_AS_METHODS +mpz_long(self, args) + mpzobject *self; + object *args; +#else /* def MPZ_CONVERSIONS_AS_METHODS */ +mpz_long(self) + mpzobject *self; +#endif /* def MPZ_CONVERSIONS_AS_METHODS else */ +{ + int i, isnegative; + unsigned long int uli; + longobject *longobjp; + int ldcount; + int bitpointer, newbitpointer; + MP_INT mpzscratch; + + +#ifdef MPZ_CONVERSIONS_AS_METHODS + if (!getnoarg(args)) + return NULL; +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + + /* determine length of python-long to be allocated */ + if ((longobjp = alloclongobject(i = (int) + ((mpz_size(&self->mpz) * BITS_PER_MP_LIMB + + SHIFT - 1) / + SHIFT))) == NULL) + return NULL; + + /* determine sign, and copy self to scratch var */ + mpz_init_set(&mpzscratch, &self->mpz); + if (isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)) + mpz_neg(&mpzscratch, &mpzscratch); + + /* let those bits come, let those bits go, + e.g. dismantle mpzscratch, build longobject */ + + bitpointer = 0; /* the number of valid bits in stock */ + newbitpointer = 0; + ldcount = 0; /* the python-long limb counter */ + uli = (unsigned long int)0; + while (i--) { + longobjp->ob_digit[ldcount] = uli & MASK; + + /* check if we've had enough bits for this digit */ + if (bitpointer < SHIFT) { + uli = mpz_get_ui(&mpzscratch); + longobjp->ob_digit[ldcount] |= + (uli << bitpointer) & MASK; + uli >>= SHIFT-bitpointer; + bitpointer += BITS_PER_MP_LIMB; + mpz_div_2exp(&mpzscratch, &mpzscratch, + BITS_PER_MP_LIMB); + } + else + uli >>= SHIFT; + bitpointer -= SHIFT; + ldcount++; + } + + assert(mpz_cmp_ui(&mpzscratch, (unsigned long int)0) == 0); + mpz_clear(&mpzscratch); + assert(ldcount <= longobjp->ob_size); + + /* long_normalize() is file-static */ + /* longobjp = long_normalize(longobjp); */ + while (ldcount > 0 && longobjp->ob_digit[ldcount-1] == 0) + ldcount--; + longobjp->ob_size = ldcount; + + + if (isnegative) + longobjp->ob_size = -longobjp->ob_size; + + return (object *)longobjp; + +} /* mpz_long() */ + + +/* I would have avoided pow() anyways, so ... */ +static const double multiplier = 256.0 * 256.0 * 256.0 * 256.0; + +#ifdef MPZ_CONVERSIONS_AS_METHODS +static object * +mpz_float(self, args) + mpzobject *self; + object *args; +#else /* def MPZ_CONVERSIONS_AS_METHODS */ +static object * +mpz_float(self) + mpzobject *self; +#endif /* def MPZ_CONVERSIONS_AS_METHODS else */ +{ + int i, isnegative; + double x; + double mulstate; + MP_INT mpzscratch; + + +#ifdef MPZ_CONVERSIONS_AS_METHODS + if (!getnoarg(args)) + return NULL; +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + + i = (int)mpz_size(&self->mpz); + + /* determine sign, and copy abs(self) to scratch var */ + if (isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)) { + mpz_init(&mpzscratch); + mpz_neg(&mpzscratch, &self->mpz); + } + else + mpz_init_set(&mpzscratch, &self->mpz); + + /* let those bits come, let those bits go, + e.g. dismantle mpzscratch, build floatobject */ + + x = 0.0; + mulstate = 1.0; + while (i--) { + x += mulstate * mpz_get_ui(&mpzscratch); + mulstate *= multiplier; + mpz_div_2exp(&mpzscratch, &mpzscratch, BITS_PER_MP_LIMB); + } + + assert(mpz_cmp_ui(&mpzscratch, (unsigned long int)0) == 0); + mpz_clear(&mpzscratch); + + if (isnegative) + x = -x; + + return newfloatobject(x); + +} /* mpz_float() */ + +#ifdef MPZ_CONVERSIONS_AS_METHODS +static object * +mpz_hex(self, args) + mpzobject *self; + object *args; +#else /* def MPZ_CONVERSIONS_AS_METHODS */ +static object * +mpz_hex(self) + mpzobject *self; +#endif /* def MPZ_CONVERSIONS_AS_METHODS else */ +{ +#ifdef MPZ_CONVERSIONS_AS_METHODS + if (!getnoarg(args)) + return NULL; +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + + return mpz_format(self, 16, (unsigned char)1); +} /* mpz_hex() */ + +#ifdef MPZ_CONVERSIONS_AS_METHODS +static object * +mpz_oct(self, args) + mpzobject *self; + object *args; +#else /* def MPZ_CONVERSIONS_AS_METHODS */ +static object * +mpz_oct(self) + mpzobject *self; +#endif /* def MPZ_CONVERSIONS_AS_METHODS else */ +{ +#ifdef MPZ_CONVERSIONS_AS_METHODS + if (!getnoarg(args)) + return NULL; +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + + return mpz_format(self, 8, (unsigned char)1); +} /* mpz_oct() */ + +static object * +mpz_binary(self, args) + mpzobject *self; + object *args; +{ + int size; + stringobject *strobjp; + char *cp; + MP_INT mp; + unsigned long ldigit; + + if (!getnoarg(args)) + return NULL; + + if (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0) { + err_setstr(ValueError, "mpz.binary() arg must be >= 0"); + return NULL; + } + + mpz_init_set(&mp, &self->mpz); + size = (int)mpz_size(&mp); + + if ((strobjp = (stringobject *) + newsizedstringobject((char *)0, + size * sizeof (unsigned long int))) == NULL) + return NULL; + + /* get the beginning of the string memory and start copying things */ + cp = GETSTRINGVALUE(strobjp); + + /* this has been programmed using a (fairly) decent lib-i/f it could + be must faster if we looked into the GMP lib */ + while (size--) { + ldigit = mpz_get_ui(&mp); + mpz_div_2exp(&mp, &mp, BITS_PER_MP_LIMB); + *cp++ = (unsigned char)(ldigit & 0xFF); + *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF); + *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF); + *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF); + } + + while (strobjp->ob_size && !*--cp) + strobjp->ob_size--; + + return (object *)strobjp; +} /* mpz_binary() */ + + +static struct methodlist mpz_methods[] = { +#ifdef MPZ_CONVERSIONS_AS_METHODS + {"int", mpz_int}, + {"long", mpz_long}, + {"float", mpz_float}, + {"hex", mpz_hex}, + {"oct", mpz_oct}, +#endif /* def MPZ_CONVERSIONS_AS_METHODS */ + {"binary", mpz_binary}, + {NULL, NULL} /* sentinel */ +}; + +static object * +mpz_getattr(self, name) + mpzobject *self; + char *name; +{ + return findmethod(mpz_methods, (object *)self, name); +} /* mpz_getattr() */ + + +static int +mpz_coerce(pv, pw) + object **pv; + object **pw; +{ + object *z; + +#ifdef MPZ_DEBUG + fputs("mpz_coerce() called...\n", stderr); +#endif /* def MPZ_DEBUG */ + + assert(is_mpzobject(*pv)); + + /* always convert other arg to mpz value, except for floats */ + if (!is_floatobject(*pw)) { + if ((z = (object *)mpz_mpzcoerce(*pw)) == NULL) + return -1; /* -1: an error always has been set */ + + INCREF(*pv); + *pw = z; + } + else { + if ((z = mpz_float(*pv, NULL)) == NULL) + return -1; + + INCREF(*pw); + *pv = z; + } + return 0; /* coercion succeeded */ + +} /* mpz_coerce() */ + + +static object * +mpz_repr(v) + object *v; +{ + return mpz_format(v, 10, (unsigned char)1); +} /* mpz_repr() */ + + + +#define UF (object* (*) FPROTO((object *))) /* Unary function */ +#define BF (object* (*) FPROTO((object *, object *))) /* Binary function */ +#define IF (int (*) FPROTO((object *))) /* Int function */ + +static number_methods mpz_as_number = { + BF mpz_addition, /*nb_add*/ + BF mpz_substract, /*nb_subtract*/ + BF mpz_multiply, /*nb_multiply*/ + BF mpz_divide, /*nb_divide*/ + BF mpz_remainder, /*nb_remainder*/ + BF mpz_div_and_mod, /*nb_divmod*/ + BF mpz_power, /*nb_power*/ + UF mpz_negative, /*nb_negative*/ + UF mpz_positive, /*tp_positive*/ + UF mpz_absolute, /*tp_absolute*/ + IF mpz_nonzero, /*tp_nonzero*/ + UF mpz_invert, /*nb_invert*/ + BF mpz_lshift, /*nb_lshift*/ + BF mpz_rshift, /*nb_rshift*/ + BF mpz_andfunc, /*nb_and*/ + BF mpz_xorfunc, /*nb_xor*/ + BF mpz_orfunc, /*nb_or*/ + (int (*) FPROTO((object **, object **))) + mpz_coerce, /*nb_coerce*/ +#ifndef MPZ_CONVERSIONS_AS_METHODS + UF mpz_int, /*nb_int*/ + UF mpz_long, /*nb_long*/ + UF mpz_float, /*nb_float*/ + UF mpz_oct, /*nb_oct*/ + UF mpz_hex, /*nb_hex*/ +#endif /* ndef MPZ_CONVERSIONS_AS_METHODS */ +}; + +static typeobject MPZtype = { + OB_HEAD_INIT(&Typetype) + 0, /*ob_size*/ + "mpz", /*tp_name*/ + sizeof(mpzobject), /*tp_size*/ + 0, /*tp_itemsize*/ + /* methods */ + mpz_dealloc, /*tp_dealloc*/ + mpz_print, /*tp_print*/ + mpz_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + mpz_compare, /*tp_compare*/ + mpz_repr, /*tp_repr*/ + &mpz_as_number, /*tp_as_number*/ +}; + +/* List of functions exported by this module */ + +static struct methodlist mpz_functions[] = { +#if 0 + {initialiser_name, MPZ_mpz}, +#else /* 0 */ + /* until guido ``fixes'' struct methodlist */ + {(char *)initialiser_name, MPZ_mpz}, +#endif /* 0 else */ + {"powm", MPZ_powm}, + {"gcd", MPZ_gcd}, + {"gcdext", MPZ_gcdext}, + {"sqrt", MPZ_sqrt}, + {"sqrtrem", MPZ_sqrtrem}, + {"divm", MPZ_divm}, + {NULL, NULL} /* Sentinel */ +}; + + +/* #define MP_TEST_ALLOC */ + +#ifdef MP_TEST_ALLOC +#define MP_TEST_SIZE 4 +static const char mp_test_magic[MP_TEST_SIZE] = {'\xAA','\xAA','\xAA','\xAA'}; +static mp_test_error( location ) + int *location; +{ + /* assumptions: *alloc returns address dividable by 4, + mpz_* routines allocate in chunks dividable by four */ + fprintf(stderr, "MP_TEST_ERROR: location holds 0x%08d\n", *location ); + fatal("MP_TEST_ERROR"); +} /* static mp_test_error() */ +#define MP_EXTRA_ALLOC(size) ((size) + MP_TEST_SIZE) +#define MP_SET_TEST(basep,size) (void)memcpy( ((char *)(basep))+(size), mp_test_magic, MP_TEST_SIZE) +#define MP_DO_TEST(basep,size) if ( !memcmp( ((char *)(basep))+(size), mp_test_magic, MP_TEST_SIZE ) ) \ + ; \ + else \ + mp_test_error((int *)((char *)(basep) + size)) +#else /* def MP_TEST_ALLOC */ +#define MP_EXTRA_ALLOC(size) (size) +#define MP_SET_TEST(basep,size) +#define MP_DO_TEST(basep,size) +#endif /* def MP_TEST_ALLOC else */ + +void *mp_allocate( alloc_size ) + size_t alloc_size; +{ + void *res; + +#ifdef MPZ_DEBUG + fprintf(stderr, "mp_allocate : size %ld\n", + alloc_size); +#endif /* def MPZ_DEBUG */ + + if ( (res = malloc(MP_EXTRA_ALLOC(alloc_size))) == NULL ) + fatal("mp_allocate failure"); + +#ifdef MPZ_DEBUG + fprintf(stderr, "mp_allocate : address 0x%08x\n", res); +#endif /* def MPZ_DEBUG */ + + MP_SET_TEST(res,alloc_size); + + return res; +} /* mp_allocate() */ + + +void *mp_reallocate( ptr, old_size, new_size ) + void *ptr; + size_t old_size; + size_t new_size; +{ + void *res; + +#ifdef MPZ_DEBUG + fprintf(stderr, "mp_reallocate: old address 0x%08x, old size %ld\n", + ptr, old_size); +#endif /* def MPZ_DEBUG */ + + MP_DO_TEST(ptr, old_size); + + if ( (res = realloc(ptr, MP_EXTRA_ALLOC(new_size))) == NULL ) + fatal("mp_reallocate failure"); + +#ifdef MPZ_DEBUG + fprintf(stderr, "mp_reallocate: new address 0x%08x, new size %ld\n", + res, new_size); +#endif /* def MPZ_DEBUG */ + + MP_SET_TEST(res, new_size); + + return res; +} /* mp_reallocate() */ + + +void mp_free( ptr, size ) + void *ptr; + size_t size; +{ + +#ifdef MPZ_DEBUG + fprintf(stderr, "mp_free : old address 0x%08x, old size %ld\n", + ptr, size); +#endif /* def MPZ_DEBUG */ + + MP_DO_TEST(ptr, size); + free(ptr); +} /* mp_free() */ + + + +/* Initialize this module. */ + +void +initmpz() +{ +#ifdef MPZ_DEBUG + fputs( "initmpz() called...\n", stderr ); +#endif /* def MPZ_DEBUG */ + + mp_set_memory_functions( mp_allocate, mp_reallocate, mp_free ); + (void)initmodule("mpz", mpz_functions); + + /* create some frequently used constants */ + if ((mpz_value_zero = newmpzobject()) == NULL) + fatal("initmpz: can't initialize mpz contstants"); + mpz_set_ui(&mpz_value_zero->mpz, (unsigned long int)0); + + if ((mpz_value_one = newmpzobject()) == NULL) + fatal("initmpz: can't initialize mpz contstants"); + mpz_set_ui(&mpz_value_one->mpz, (unsigned long int)1); + + if ((mpz_value_mone = newmpzobject()) == NULL) + fatal("initmpz: can't initialize mpz contstants"); + mpz_set_si(&mpz_value_mone->mpz, (long)-1); + +} /* initmpz() */ +#ifdef MAKEDUMMYINT +int _mpz_dummy_int; /* XXX otherwise, we're .bss-less (DYNLOAD->Jack?) */ +#endif /* def MAKEDUMMYINT */ diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c index c66d38c..c72c9fd 100644 --- a/Modules/socketmodule.c +++ b/Modules/socketmodule.c @@ -975,6 +975,10 @@ socket_fromfd(self, args) if (!getargs(args, "(iiii)", &fd, &family, &type, &proto)) return NULL; } + /* Dup the fd so it and the socket can be closed independently */ + fd = dup(fd); + if (fd < 0) + return socket_error(); s = newsockobject(fd, family, type, proto); /* From now on, ignore SIGPIPE and let the error checking do the work. */ diff --git a/Python/ceval.c b/Python/ceval.c index 86ee6cf..e548763 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -790,6 +790,8 @@ eval_code(co, globals, locals, arg) (a) f(a,b,...) should accept f((1,2,...)) (b) f((a,b,...)) should accept f(1,2,...) (c) f(self,(a,b,...)) should accept f(x,1,2,...) + Actually, (c) is dangerous, and (b) seems + unnecessary, but (a) can't be missed... */ { int n; @@ -817,6 +819,7 @@ eval_code(co, globals, locals, arg) n = gettuplesize(v); } } +#if 0 /* Compatibility hacks no longer needed (I think) */ else if (n != 1 && oparg == 1) { /* Rule (b) */ PUSH(v); @@ -848,6 +851,7 @@ eval_code(co, globals, locals, arg) v = u; n = 2; } +#endif /* Disabled compatibility hacks */ if (n != oparg) { err_setstr(TypeError, "arg count mismatch"); |