cpython-lru_cache-weakref: Modules/mpzmodule.c annotate

annotate Modules/mpzmodule.c @ 1590:ac2e5cc29949 legacy-trunk

Added tests for missing host to open_http and open_gopher

author	Guido van Rossum <guido@python.org>
date	Mon, 18 Apr 1994 09:39:56 +0000
parents	72bddfad351a
children	1940892d2fe3

rev	line source
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1 /***********************************************************
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	2 Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	3 Netherlands.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	4
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	5 All Rights Reserved
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	6
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	7 Permission to use, copy, modify, and distribute this software and its
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	8 documentation for any purpose and without fee is hereby granted,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	9 provided that the above copyright notice appear in all copies and that
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	10 both that copyright notice and this permission notice appear in
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	11 supporting documentation, and that the names of Stichting Mathematisch
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	12 Centrum or CWI not be used in advertising or publicity pertaining to
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	13 distribution of the software without specific, written prior permission.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	14
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	22
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	23 ******************************************************************/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	24 /* MPZ module */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	25
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	26 /* This module provides an interface to an alternate Multi-Precision
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	27 library, GNU MP in this case */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	28
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	29 /* XXX note: everywhere where mpz_size is called,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	30 sizeof (limb) == sizeof (long) has been assumed. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	31
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	32
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	33 /* MPZ objects */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	34
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	35 #include "allobjects.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	36 #include "modsupport.h" /* For getargs() etc. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	37 #include <assert.h>
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	38
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	39 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	40 ** These are the cpp-flags used in this file...
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	41 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	42 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	43 ** MPZ_MDIV_BUG works around the mpz_m{div,mod,...} routines.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	44 ** This bug has been fixed in a later release of
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	45 ** GMP.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	46 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	47 ** MPZ_GET_STR_BUG mpz_get_str corrupts memory, seems to be fixed
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	48 ** in a later release
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	49 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	50 ** MPZ_DEBUG generates a bunch of diagnostic messages
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	51 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	52 ** MPZ_SPARE_MALLOC if set, results in extra code that tries to
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	53 ** minimize the creation of extra objects.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	54 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	55 ** MPZ_TEST_DIV extra diagnostic output on stderr, when division
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	56 ** routines are involved
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	57 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	58 ** MPZ_LIB_DOES_CHECKING if set, assumes that mpz library doesn't call
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	59 ** alloca with arg < 0 (when casted to a signed
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	60 ** integral type).
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	61 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	62 ** MPZ_CONVERSIONS_AS_METHODS if set, presents the conversions as
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	63 ** methods. e.g., `mpz(5).long() == 5L'
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	64 ** Later, Guido provided an interface to the
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	65 ** standard functions. So this flag has no been
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	66 ** cleared, and `long(mpz(5)) == 5L'
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	67 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	68 ** MP_TEST_ALLOC If set, you would discover why MPZ_GET_STR_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	69 ** is needed
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	70 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	71 ** MAKEDUMMYINT Must be set if dynamic linking will be used
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	72 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	73
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	74
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	75 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	76 ** IMHO, mpz_m{div,mod,divmod}() do the wrong things when the denominator < 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	77 ** I assume that this will be fixed in a future release
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	78 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	79 /#define MPZ_MDIV_BUG fixed the (for me) nexessary parts in libgmp.a /
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	80 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	81 ** IMO, mpz_get_str() assumes a bit too large target space, if he doesn't
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	82 ** allocate it himself
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	83 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	84 #define MPZ_GET_STR_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	85
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	86 #include "gmp.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	87 typedef struct {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	88 OB_HEAD
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	89 MP_INT mpz; /* the actual number */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	90 } mpzobject;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	91
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	92 extern typeobject MPZtype; /* Really static, forward */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	93
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	94 #define is_mpzobject(v) ((v)->ob_type == &MPZtype)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	95
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	96 static const char initialiser_name[] = "mpz";
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	97
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	98 /* #define MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	99
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	100 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	101 newmpzobject()
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	102 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	103 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	104
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	105
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	106 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	107 fputs( "mpz_object() called...\n", stderr );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	108 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	109 mpzp = NEWOBJ(mpzobject, &MPZtype);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	110 if (mpzp == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	111 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	112
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	113 mpz_init(&mpzp->mpz); /* actual initialisation */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	114 return mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	115 } /* newmpzobject() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	116
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	117 #ifdef MPZ_GET_STR_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	118 #include "gmp-impl.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	119 #include "longlong.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	120 #endif /* def MPZ_GET_STR_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	121
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	122 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	123 mpz_format(objp, base, withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	124 object *objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	125 int base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	126 unsigned char withname;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	127 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	128 mpzobject mpzp = (mpzobject )objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	129 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	130 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	131 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	132 int taglong;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	133 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	134 char prefix[5], *tcp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	135
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	136
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	137 tcp = &prefix[0];
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	138
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	139 if (mpzp == NULL \|\| !is_mpzobject(mpzp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	140 err_badcall();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	141 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	142 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	143
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	144 assert(base >= 2 && base <= 36);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	145
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	146 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	147 i = strlen(initialiser_name) + 2; /* e.g. 'mpz(' + ')' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	148 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	149 i = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	150
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	151 if ((cmpres = mpz_cmp_si(&mpzp->mpz, 0L)) == 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	152 base = 10; /* '0' in every base, right */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	153 else if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	154 *tcp++ = '-';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	155 i += 1; /* space to hold '-' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	156 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	157
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	158 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	159 fprintf(stderr, "mpz_format: mpz_sizeinbase %d\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	160 (int)mpz_sizeinbase(&mpzp->mpz, base));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	161 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	162 #ifdef MPZ_GET_STR_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	163 i += ((size_t) abs(mpzp->mpz.size) * BITS_PER_MP_LIMB
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	164 * __mp_bases[base].chars_per_bit_exactly) + 1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	165 #else /* def MPZ_GET_STR_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	166 i += (int)mpz_sizeinbase(&mpzp->mpz, base);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	167 #endif /* def MPZ_GET_STR_BUG else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	168
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	169 if (base == 16) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	170 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	171 *tcp++ = 'x';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	172 i += 2; /* space to hold '0x' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	173 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	174 else if (base == 8) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	175 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	176 i += 1; /* space to hold the extra '0' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	177 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	178 else if (base > 10) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	179 *tcp++ = '0' + base / 10;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	180 *tcp++ = '0' + base % 10;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	181 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	182 i += 3; /* space to hold e.g. '12#' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	183 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	184 else if (base < 10) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	185 *tcp++ = '0' + base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	186 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	187 i += 2; /* space to hold e.g. '6#' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	188 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	189
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	190 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	191 ** the following code looks if we need a 'L' attached to the number
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	192 ** it will also attach an 'L' to the value -0x80000000
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	193 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	194 taglong = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	195 if (mpz_size(&mpzp->mpz) > 1
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	196 \|\| (long)mpz_get_ui(&mpzp->mpz) < 0L) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	197 taglong = 1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	198 i += 1; /* space to hold 'L' */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	199 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	200
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	201 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	202 fprintf(stderr, "mpz_format: requesting string size %d\n", i);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	203 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	204 if ((strobjp = (stringobject )newsizedstringobject((char )0, i))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	205 == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	206 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	207
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	208 /* get the beginning of the string memory and start copying things */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	209 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	210 if (withname) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	211 strcpy(cp, initialiser_name);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	212 cp += strlen(initialiser_name);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	213 cp++ = '('; /')'*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	214 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	215
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	216 /* copy the already prepared prefix; e.g. sign and base indicator */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	217 *tcp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	218 strcpy(cp, prefix);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	219 cp += tcp - prefix;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	220
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	221 /* since' we have the sign already, let the lib think it's a positive
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	222 number */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	223 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	224 mpz_neg(&mpzp->mpz,&mpzp->mpz); /* hack Hack HAck HACk HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	225 (void)mpz_get_str(cp, base, &mpzp->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	226 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	227 mpz_neg(&mpzp->mpz,&mpzp->mpz); /* hack Hack HAck HACk HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	228 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	229 fprintf(stderr, "mpz_format: base (ultim) %d, mpz_get_str: %s\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	230 base, cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	231 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	232 cp += strlen(cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	233
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	234 if (taglong)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	235 *cp++ = 'L';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	236 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	237 cp++ = /'('*/ ')';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	238
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	239 *cp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	240
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	241 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	242 fprintf(stderr,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	243 "mpz_format: cp (str end) 0x%x, begin 0x%x, diff %d, i %d\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	244 cp, GETSTRINGVALUE(strobjp), cp - GETSTRINGVALUE(strobjp), i);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	245 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	246 assert(cp - GETSTRINGVALUE(strobjp) <= i);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	247
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	248 if (cp - GETSTRINGVALUE(strobjp) != i) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	249 strobjp->ob_size -= i - (cp - GETSTRINGVALUE(strobjp));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	250 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	251
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	252 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	253 } /* mpz_format() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	254
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	255 /* MPZ methods */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	256
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	257 static void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	258 mpz_dealloc(mpzp)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	259 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	260 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	261 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	262 fputs( "mpz_dealloc() called...\n", stderr );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	263 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	264 mpz_clear(&mpzp->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	265 DEL(mpzp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	266 } /* mpz_dealloc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	267
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	268
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	269 /* pointers to frequently used values 0, 1 and -1 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	270 static mpzobject mpz_value_zero, mpz_value_one, *mpz_value_mone;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	271
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	272 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	273 mpz_compare(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	274 mpzobject a, b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	275 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	276 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	277
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	278
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	279 /* guido sez it's better to return -1, 0 or 1 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	280 return (cmpres = mpz_cmp( &a->mpz, &b->mpz )) == 0 ? 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	281 : cmpres > 0 ? 1 : -1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	282 } /* mpz_compare() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	283
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	284 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	285 mpz_addition(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	286 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	287 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	288 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	289 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	290
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	291
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	292 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	293 if (mpz_cmp_ui(&a->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	294 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	295 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	296 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	297
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	298 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	299 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	300 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	301 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	302 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	303
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	304 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	305 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	306
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	307 mpz_add(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	308 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	309 } /* mpz_addition() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	310
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	311 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	312 mpz_substract(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	313 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	314 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	315 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	316 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	317
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	318
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	319 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	320 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	321 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	322 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	323 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	324 #endif /* MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	325
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	326 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	327 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	328
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	329 mpz_sub(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	330 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	331 } /* mpz_substract() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	332
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	333 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	334 mpz_multiply(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	335 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	336 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	337 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	338 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	339 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	340 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	341 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	342
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	343
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	344 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	345 if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	346 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	347 return (object *)mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	348 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	349 if (cmpres > 0 && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	350 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	351 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	352 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	353
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	354 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long_int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	355 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	356 return (object *)mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	357 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	358 if (cmpres > 0 && mpz_cmp_ui(&b->mpz, (unsigned long int)1) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	359 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	360 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	361 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	362 #endif /* MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	363
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	364 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	365 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	366
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	367 mpz_mul( &z->mpz, &a->mpz, &b->mpz );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	368 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	369
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	370 } /* mpz_multiply() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	371
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	372 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	373 mpz_divide(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	374 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	375 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	376 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	377 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	378 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	379 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	380 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	381
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	382
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	383 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	384 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	385 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	386 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	387 mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	388 err_setstr(ZeroDivisionError, "mpz./ by zero");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	389 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	390 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	391 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	392 if (cmpres > 0 && mpz_cmp_ui(&b->mpz(unsigned long int)1) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	393 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	394 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	395 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	396 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	397
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	398 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	399 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	400
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	401 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	402 fputs("mpz_divide: div result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	403 mpz_div(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	404 mpz_out_str(stderr, 10, &z->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	405 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	406 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	407 #ifdef MPZ_MDIV_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	408 if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	409 != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	410 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	411 ** numerator has other sign than denominator: we have
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	412 ** to look at the remainder for a correction, since mpz_mdiv
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	413 ** also calls mpz_divmod, I can as well do it myself
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	414 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	415 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	416
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	417
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	418 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	419 mpz_divmod(&z->mpz, &tmpmpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	420
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	421 if (mpz_cmp_ui(&tmpmpz, (unsigned long int)0) != 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	422 mpz_sub_ui(&z->mpz, &z->mpz, (unsigned long int)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	423
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	424 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	425 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	426 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	427 mpz_div(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	428 /* the ``naive'' implementation does it right for operands
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	429 having the same sign */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	430
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	431 #else /* def MPZ_MDIV_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	432 mpz_mdiv(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	433 #endif /* def MPZ_MDIV_BUG else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	434 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	435 fputs("mpz_divide: mdiv result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	436 mpz_out_str(stderr, 10, &z->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	437 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	438 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	439 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	440
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	441 } /* mpz_divide() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	442
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	443 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	444 mpz_remainder(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	445 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	446 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	447 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	448 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	449 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	450 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	451 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	452
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	453
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	454 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	455 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	456 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	457 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	458 mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	459 err_setstr(ZeroDivisionError, "mpz.% by zero");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	460 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	461 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	462 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	463 if (cmpres > 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	464 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)2)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	465 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	466 return (object *)mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	467 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	468 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	469 /* b must be 1 now */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	470 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	471 return (object *)mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	472 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	473 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	474 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	475
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	476 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	477 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	478
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	479 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	480 fputs("mpz_remain: mod result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	481 mpz_mod(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	482 mpz_out_str(stderr, 10, &z->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	483 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	484 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	485 #ifdef MPZ_MDIV_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	486
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	487 /* the ``naive'' implementation does it right for operands
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	488 having the same sign */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	489 mpz_mod(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	490
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	491 /* assumption: z, a and b all point to different locations */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	492 if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	493 != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	494 && mpz_cmp_ui(&z->mpz, (unsigned long int)0) != 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	495 mpz_add(&z->mpz, &z->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	496 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	497 ** numerator has other sign than denominator: we have
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	498 ** to look at the remainder for a correction, since mpz_mdiv
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	499 ** also calls mpz_divmod, I can as well do it myself
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	500 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	501 #else /* def MPZ_MDIV_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	502 mpz_mmod(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	503 #endif /* def MPZ_MDIV_BUG else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	504 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	505 fputs("mpz_remain: mmod result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	506 mpz_out_str(stderr, 10, &z->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	507 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	508 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	509 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	510
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	511 } /* mpz_remainder() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	512
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	513 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	514 mpz_div_and_mod(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	515 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	516 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	517 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	518 object *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	519 mpzobject x = NULL, y = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	520
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	521
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	522 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	523 err_setstr(ZeroDivisionError, "mpz.divmod by zero");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	524 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	525 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	526
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	527 if ((z = newtupleobject(2)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	528 \|\| (x = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	529 \|\| (y = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	530 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	531 XDECREF(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	532 XDECREF(y);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	533 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	534 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	535
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	536 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	537 fputs("mpz_divmod: dm result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	538 mpz_divmod(&x->mpz, &y->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	539 mpz_out_str(stderr, 10, &x->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	540 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	541 mpz_out_str(stderr, 10, &y->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	542 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	543 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	544 #ifdef MPZ_MDIV_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	545 mpz_divmod(&x->mpz, &y->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	546 if ((mpz_cmp_ui(&a->mpz, (unsigned long int)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	547 != (mpz_cmp_ui(&b->mpz, (unsigned long int)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	548 && mpz_cmp_ui(&y->mpz, (unsigned long int)0) != 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	549 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	550 ** numerator has other sign than denominator: we have
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	551 ** to look at the remainder for a correction.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	552 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	553 mpz_add(&y->mpz, &y->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	554 mpz_sub_ui(&x->mpz, &x->mpz, (unsigned long int)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	555 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	556 #else /* def MPZ_MDIV_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	557 mpz_mdivmod( &x->mpz, &y->mpz, &a->mpz, &b->mpz );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	558 #endif /* def MPZ_MDIV_BUG else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	559 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	560 fputs("mpz_divmod: mdm result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	561 mpz_out_str(stderr, 10, &x->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	562 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	563 mpz_out_str(stderr, 10, &y->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	564 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	565 #endif /* def MPZ_TEST_DIV */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	566
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	567 (void)settupleitem(z, 0, (object *)x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	568 (void)settupleitem(z, 1, (object *)y);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	569
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	570 return z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	571 } /* mpz_div_and_mod() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	572
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	573 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	574 mpz_power(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	575 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	576 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	577 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	578 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	579 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	580 long int longtmp1, longtmp2;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	581
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	582
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	583 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	584 /* the gnu-mp lib sets pow(0,0) to 0, we to 1 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	585
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	586 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	587 return (object *)mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	588 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	589
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	590 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	591 err_setstr(ValueError, "mpz.pow to negative exponent");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	592 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	593 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	594
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	595 if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	596 /* the base is 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	597
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	598 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	599 return (object *)mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	600 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	601 else if (cmpres > 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	602 && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	603 /* the base is 1 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	604
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	605 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	606 return (object *)mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	607 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	608 else if (cmpres < 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	609 && mpz_cmp_si(&a->mpz, (long int)-1) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	610
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	611 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	612 /* the base is -1: pow(-1, any) == 1,-1 for even,uneven b */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	613 /* XXX this code needs to be optimized: what's better?
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	614 mpz_mmod_ui or mpz_mod_2exp, I choose for the latter
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	615 for unobvious reasons */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	616
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	617 /* is the exponent even? */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	618 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	619
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	620 /* look to the remainder after a division by (1 << 1) */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	621 mpz_mod_2exp(&tmpmpz, &b->mpz, (unsigned long int)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	622
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	623 if (mpz_cmp_ui(&tmpmpz, (unsigned int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	624 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	625 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	626 return (object *)mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	627 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	628 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	629 INCREF(mpz_value_mone);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	630 return (object *)mpz_value_mone;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	631 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	632
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	633 #ifdef MPZ_LIB_DOES_CHECKING
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	634 /* check if it's doable: sizeof(exp) > sizeof(long) &&
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	635 abs(base) > 1 ?? --> No Way */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	636 if (mpz_size(&b->mpz) > 1)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	637 return (object *)err_nomem();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	638 #else /* def MPZ_LIB_DOES_CHECKING */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	639 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	640 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	641 err_setstr(ValueError, "mpz.pow outrageous exponent");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	642 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	643 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	644 #endif /* def MPZ_LIB_DOES_CHECKING else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	645
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	646 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	647 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	648
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	649 mpz_pow_ui(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	650
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	651 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	652 } /* mpz_power() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	653
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	654
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	655 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	656 mpz_negative(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	657 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	658 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	659 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	660
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	661
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	662 #ifdef MPZ_SPARE_MALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	663 if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	664 /* -0 == 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	665 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	666 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	667 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	668 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	669
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	670 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	671 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	672
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	673 mpz_neg(&z->mpz, &v->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	674 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	675 } /* mpz_negative() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	676
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	677
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	678 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	679 mpz_positive(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	680 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	681 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	682 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	683 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	684 } /* mpz_positive() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	685
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	686
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	687 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	688 mpz_absolute(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	689 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	690 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	691 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	692
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	693
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	694 if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) >= 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	695 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	696 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	697 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	698
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	699 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	700 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	701
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	702 mpz_neg(&z->mpz, &v->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	703 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	704 } /* mpz_absolute() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	705
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	706 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	707 mpz_nonzero(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	708 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	709 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	710 return mpz_cmp_ui(&v->mpz, (unsigned long int)0) != 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	711 } /* mpz_nonzero() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	712
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	713 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	714 mpz_invert(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	715 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	716 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	717 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	718
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	719
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	720 /* I think mpz_com does exactly what needed */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	721 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	722 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	723
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	724 mpz_com(&z->mpz, &v->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	725 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	726 } /* mpz_invert() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	727
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	728 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	729 mpz_lshift(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	730 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	731 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	732 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	733 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	734 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	735
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	736
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	737 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	738 /* a << 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	739 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	740 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	741 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	742
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	743 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	744 err_setstr(ValueError, "mpz.<< negative shift count");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	745 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	746 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	747
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	748 #ifdef MPZ_LIB_DOES_CHECKING
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	749 if (mpz_size(&b->mpz) > 1)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	750 return (object *)err_nomem();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	751 #else /* def MPZ_LIB_DOES_CHECKING */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	752 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	753 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	754 err_setstr(ValueError, "mpz.<< outrageous shift count");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	755 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	756 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	757 #endif /* def MPZ_LIB_DOES_CHECKING else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	758
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	759 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	760 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	761
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	762 mpz_mul_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	763 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	764 } /* mpz_lshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	765
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	766 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	767 mpz_rshift(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	768 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	769 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	770 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	771 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	772 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	773
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	774
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	775 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	776 /* a >> 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	777 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	778 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	779 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	780
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	781 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	782 err_setstr(ValueError, "mpz.>> negative shift count");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	783 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	784 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	785
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	786 if (mpz_size(&b->mpz) > 1)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	787 return (object *)err_nomem();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	788
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	789 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	790 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	791
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	792 mpz_div_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	793 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	794 } /* mpz_rshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	795
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	796 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	797 mpz_andfunc(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	798 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	799 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	800 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	801 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	802
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	803
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	804 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	805 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	806
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	807 mpz_and(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	808 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	809 } /* mpz_andfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	810
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	811 /* hack Hack HAck HACk HACK, XXX this code is dead slow */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	812 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	813 mpz_xor(res, op1, op2)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	814 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	815 const MP_INT *op1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	816 const MP_INT *op2;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	817 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	818 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	819
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	820 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	821
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	822 mpz_and(res, op1, op2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	823 mpz_com(&tmpmpz, res);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	824 mpz_ior(res, op1, op2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	825 mpz_and(res, res, &tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	826
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	827 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	828 } /* mpz_xor() HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	829
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	830 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	831 mpz_xorfunc(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	832 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	833 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	834 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	835 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	836
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	837
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	838 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	839 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	840
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	841 mpz_xor(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	842 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	843 } /* mpz_xorfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	844
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	845 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	846 mpz_orfunc(a, b)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	847 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	848 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	849 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	850 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	851
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	852
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	853 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	854 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	855
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	856 mpz_ior(&z->mpz, &a->mpz, &b->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	857 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	858 } /* mpz_orfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	859
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	860 /* MPZ initialisation */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	861
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	862 #include "longintrepr.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	863
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	864 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	865 MPZ_mpz(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	866 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	867 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	868 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	869 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	870 object *objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	871
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	872
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	873 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	874 fputs("MPZ_mpz() called...\n", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	875 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	876
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	877 if (!getargs(args, "O", &objp))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	878 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	879
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	880 /* at least we know it's some object */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	881 /* note DON't DECREF args NEITHER objp */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	882
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	883 if (is_intobject(objp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	884 long lval;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	885
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	886 if (!getargs(objp, "l", &lval))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	887 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	888
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	889 if (lval == (long)0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	890 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	891 mpzp = mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	892 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	893 else if (lval == (long)1) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	894 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	895 mpzp = mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	896 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	897 else if ((mpzp = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	898 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	899 else mpz_set_si(&mpzp->mpz, lval);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	900 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	901 else if (is_longobject(objp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	902 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	903 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	904 unsigned char isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	905
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	906
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	907 if ((mpzp = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	908 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	909
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	910 mpz_set_si(&mpzp->mpz, 0L);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	911 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	912
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	913 /* how we're gonna handle this? */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	914 if (isnegative = ((i = ((longobject *)objp)->ob_size) < 0) )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	915 i = -i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	916
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	917 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	918 mpz_set_ui(&mplongdigit,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	919 (unsigned long)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	920 ((longobject *)objp)->ob_digit[i]);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	921 mpz_mul_2exp(&mplongdigit,&mplongdigit,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	922 (unsigned long int)i * SHIFT);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	923 mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	924 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	925
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	926 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	927 mpz_neg(&mpzp->mpz, &mpzp->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	928
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	929 /* get rid of allocation for tmp variable */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	930 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	931 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	932 else if (is_stringobject(objp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	933 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	934 int len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	935 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	936
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	937 if (!getargs(objp, "s#", &cp, &len))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	938 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	939
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	940 if ((mpzp = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	941 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	942
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	943 mpz_set_si(&mpzp->mpz, 0L);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	944 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	945
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	946 /* let's do it the same way as with the long conversion:
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	947 without thinking how it can be faster (-: :-) */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	948
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	949 cp += len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	950 while (len--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	951 mpz_set_ui(&mplongdigit, (unsigned long)*--cp );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	952 mpz_mul_2exp(&mplongdigit,&mplongdigit,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	953 (unsigned long int)len * 8);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	954 mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	955 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	956
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	957 /* get rid of allocation for tmp variable */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	958 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	959 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	960 else if (is_mpzobject(objp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	961 INCREF(objp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	962 mpzp = (mpzobject *)objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	963 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	964 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	965 err_setstr(TypeError,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	966 "mpz.mpz() expects integer, long, string or mpz object argument");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	967 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	968 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	969
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	970
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	971 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	972 fputs("MPZ_mpz: created mpz=", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	973 mpz_out_str(stderr, 10, &mpzp->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	974 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	975 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	976 return (object *)mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	977 } /* MPZ_mpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	978
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	979 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	980 mpz_mpzcoerce(z)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	981 object *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	982 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	983 /* shortcut: 9 out of 10 times the type is already ok */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	984 if (is_mpzobject(z)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	985 INCREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	986 return (mpzobject )z; / coercion succeeded */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	987 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	988
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	989 /* what types do we accept?: intobjects and longobjects */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	990 if (is_intobject(z) \|\| is_longobject(z))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	991 return (mpzobject )MPZ_mpz((object )NULL, z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	992
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	993 err_setstr(TypeError, "number coercion (to mpzobject) failed");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	994 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	995 } /* mpz_mpzcoerce() */
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	996
72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	997 static void mpz_divm();
72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	998
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	999 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1000 MPZ_powm(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1001 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1002 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1003 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1004 object base, exp, *mod;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1005 mpzobject mpzbase = NULL, mpzexp = NULL, *mpzmod = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1006 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1007 int tstres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1008
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1009
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1010 if (!getargs(args, "(OOO)", &base, &exp, &mod))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1011 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1012
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1013 if ((mpzbase = mpz_mpzcoerce(base)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1014 \|\| (mpzexp = mpz_mpzcoerce(exp)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1015 \|\| (mpzmod = mpz_mpzcoerce(mod)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1016 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1017 XDECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1018 XDECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1019 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1020 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1021 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1022
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1023 if ((tstres=mpz_cmp_ui(&mpzexp->mpz, (unsigned long int)0)) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1024 INCREF(mpz_value_one);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1025 return (object *)mpz_value_one;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1026 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1027
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1028 if (tstres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1029 MP_INT absexp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1030 /* negative exp */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1031
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1032 mpz_init_set(&absexp, &mpzexp->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1033 mpz_abs(&absexp, &absexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1034 mpz_powm(&z->mpz, &mpzbase->mpz, &absexp, &mpzmod->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1035
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1036 mpz_divm(&z->mpz, &mpz_value_one->mpz, &z->mpz, &mpzmod->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1037
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1038 mpz_clear(&absexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1039 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1040 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1041 mpz_powm(&z->mpz, &mpzbase->mpz, &mpzexp->mpz, &mpzmod->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1042 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1043
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1044 DECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1045 DECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1046 DECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1047
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1048 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1049 } /* MPZ_powm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1050
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1051
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1052 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1053 MPZ_gcd(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1054 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1055 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1056 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1057 object op1, op2;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1058 mpzobject mpzop1 = NULL, mpzop2 = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1059 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1060
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1061
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1062 if (!getargs(args, "(OO)", &op1, &op2))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1063 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1064
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1065 if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1066 \|\| (mpzop2 = mpz_mpzcoerce(op2)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1067 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1068 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1069 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1070 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1071 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1072
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1073 /* ok, we have three mpzobjects, and an initialised result holder */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1074 mpz_gcd(&z->mpz, &mpzop1->mpz, &mpzop2->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1075
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1076 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1077 DECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1078
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1079 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1080 } /* MPZ_gcd() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1081
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1082
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1083 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1084 MPZ_gcdext(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1085 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1086 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1087 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1088 object op1, op2, *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1089 mpzobject mpzop1 = NULL, mpzop2 = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1090 mpzobject g = NULL, s = NULL, *t = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1091
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1092
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1093 if (!getargs(args, "(OO)", &op1, &op2))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1094 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1095
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1096 if ((mpzop1 = mpz_mpzcoerce(op1)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1097 \|\| (mpzop2 = mpz_mpzcoerce(op2)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1098 \|\| (z = newtupleobject(3)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1099 \|\| (g = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1100 \|\| (s = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1101 \|\| (t = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1102 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1103 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1104 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1105 XDECREF(g);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1106 XDECREF(s);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1107 /XDECREF(t);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1108 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1109 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1110
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1111 mpz_gcdext(&g->mpz, &s->mpz, &t->mpz, &mpzop1->mpz, &mpzop2->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1112
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1113 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1114 DECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1115
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1116 (void)settupleitem(z, 0, (object *)g);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1117 (void)settupleitem(z, 1, (object *)s);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1118 (void)settupleitem(z, 2, (object *)t);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1119
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1120 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1121 } /* MPZ_gcdext() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1122
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1123
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1124 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1125 MPZ_sqrt(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1126 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1127 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1128 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1129 object *op;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1130 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1131 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1133
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1134 if (!getargs(args, "O", &op))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1135 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1136
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1137 if ((mpzop = mpz_mpzcoerce(op)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1138 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1139 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1140 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1141 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1142
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1143 mpz_sqrt(&z->mpz, &mpzop->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1144
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1145 DECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1146
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1147 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1148 } /* MPZ_sqrt() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1149
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1150
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1151 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1152 MPZ_sqrtrem(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1153 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1154 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1155 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1156 object op, z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1157 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1158 mpzobject root = NULL, rem = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1159
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1160
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1161 if (!getargs(args, "O", &op))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1162 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1163
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1164 if ((mpzop = mpz_mpzcoerce(op)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1165 \|\| (z = newtupleobject(2)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1166 \|\| (root = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1167 \|\| (rem = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1168 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1169 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1170 XDECREF(root);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1171 /XDECREF(rem);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1172 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1173 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1174
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1175 mpz_sqrtrem(&root->mpz, &rem->mpz, &mpzop->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1176
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1177 DECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1178
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1179 (void)settupleitem(z, 0, (object *)root);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1180 (void)settupleitem(z, 1, (object *)rem);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1181
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1182 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1183 } /* MPZ_sqrtrem() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1184
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1185
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1186 static void
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1187 #if __STDC__
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1188 mpz_divm(MP_INT res, const MP_INT num, const MP_INT den, const MP_INT mod)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1189 #else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1190 mpz_divm(res, num, den, mod)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1191 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1192 const MP_INT *num;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1193 const MP_INT *den;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1194 const MP_INT *mod;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1195 #endif
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1196 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1197 MP_INT s0, s1, q, r, x, d0, d1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1198
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1199 mpz_init_set(&s0, num);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1200 mpz_init_set_ui(&s1, 0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1201 mpz_init(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1202 mpz_init(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1203 mpz_init(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1204 mpz_init_set(&d0, den);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1205 mpz_init_set(&d1, mod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1206
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1207 while (d1.size != 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1208 mpz_divmod(&q, &r, &d0, &d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1209 mpz_set(&d0, &d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1210 mpz_set(&d1, &r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1211
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1212 mpz_mul(&x, &s1, &q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1213 mpz_sub(&x, &s0, &x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1214 mpz_set(&s0, &s1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1215 mpz_set(&s1, &x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1216 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1217
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1218 if (d0.size != 1 \|\| d0.d[0] != 1)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1219 res->size = 0; /* trouble: the gcd != 1; set s to zero */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1220 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1221 #ifdef MPZ_MDIV_BUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1222 /* watch out here! first check the signs, and then perform
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1223 the mpz_mod() since mod could point to res */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1224 if ((s0.size < 0) != (mod->size < 0)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1225 mpz_mod(res, &s0, mod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1226
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1227 if (res->size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1228 mpz_add(res, res, mod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1229 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1230 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1231 mpz_mod(res, &s0, mod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1232
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1233 #else /* def MPZ_MDIV_BUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1234 mpz_mmod(res, &s0, mod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1235 #endif /* def MPZ_MDIV_BUG else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1236 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1237
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1238 mpz_clear(&s0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1239 mpz_clear(&s1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1240 mpz_clear(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1241 mpz_clear(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1242 mpz_clear(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1243 mpz_clear(&d0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1244 mpz_clear(&d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1245 } /* mpz_divm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1246
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1247
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1248 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1249 MPZ_divm(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1250 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1251 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1252 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1253 object num, den, *mod;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1254 mpzobject mpznum, mpzden, *mpzmod = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1255 mpzobject *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1256
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1257
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1258 if (!getargs(args, "(OOO)", &num, &den, &mod))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1259 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1260
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1261 if ((mpznum = mpz_mpzcoerce(num)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1262 \|\| (mpzden = mpz_mpzcoerce(den)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1263 \|\| (mpzmod = mpz_mpzcoerce(mod)) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1264 \|\| (z = newmpzobject()) == NULL ) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1265 XDECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1266 XDECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1267 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1268 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1269 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1270
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1271 mpz_divm(&z->mpz, &mpznum->mpz, &mpzden->mpz, &mpzmod->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1272
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1273 DECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1274 DECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1275 DECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1276
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1277 if (mpz_cmp_ui(&z->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1278 DECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1279 err_setstr(ValueError, "gcd(den, mod) != 1 or num == 0");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1280 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1281 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1282
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1283 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1284 } /* MPZ_divm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1285
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1286
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1287 /* MPZ methods-as-attributes */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1288 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1289 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1290 mpz_int(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1291 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1292 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1293 #else /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1294 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1295 mpz_int(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1296 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1297 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1298 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1299 long sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1300
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1301
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1302 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1303 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1304 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1305 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1306
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1307 if (mpz_size(&self->mpz) > 1
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1308 \|\| (sli = (long)mpz_get_ui(&self->mpz)) < (long)0 ) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1309 err_setstr(ValueError, "mpz.int() arg too long to convert");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1310 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1311 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1312
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1313 if (mpz_cmp_ui(&self->mpz, (unsigned long)0) < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1314 sli = -sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1315
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1316 return newintobject(sli);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1317 } /* mpz_int() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1318
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1319 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1320 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1321 mpz_long(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1322 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1323 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1324 #else /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1325 mpz_long(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1326 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1327 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1328 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1329 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1330 unsigned long int uli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1331 longobject *longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1332 int ldcount;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1333 int bitpointer, newbitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1334 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1335
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1336
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1337 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1338 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1339 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1340 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1341
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1342 /* determine length of python-long to be allocated */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1343 if ((longobjp = alloclongobject(i = (int)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1344 ((mpz_size(&self->mpz) * BITS_PER_MP_LIMB
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1345 + SHIFT - 1) /
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1346 SHIFT))) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1347 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1348
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1349 /* determine sign, and copy self to scratch var */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1350 mpz_init_set(&mpzscratch, &self->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1351 if (isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1352 mpz_neg(&mpzscratch, &mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1353
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1354 /* let those bits come, let those bits go,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1355 e.g. dismantle mpzscratch, build longobject */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1356
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1357 bitpointer = 0; /* the number of valid bits in stock */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1358 newbitpointer = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1359 ldcount = 0; /* the python-long limb counter */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1360 uli = (unsigned long int)0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1361 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1362 longobjp->ob_digit[ldcount] = uli & MASK;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1363
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1364 /* check if we've had enough bits for this digit */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1365 if (bitpointer < SHIFT) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1366 uli = mpz_get_ui(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1367 longobjp->ob_digit[ldcount] \|=
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1368 (uli << bitpointer) & MASK;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1369 uli >>= SHIFT-bitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1370 bitpointer += BITS_PER_MP_LIMB;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1371 mpz_div_2exp(&mpzscratch, &mpzscratch,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1372 BITS_PER_MP_LIMB);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1373 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1374 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1375 uli >>= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1376 bitpointer -= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1377 ldcount++;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1378 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1379
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1380 assert(mpz_cmp_ui(&mpzscratch, (unsigned long int)0) == 0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1381 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1382 assert(ldcount <= longobjp->ob_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1383
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1384 /* long_normalize() is file-static */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1385 /* longobjp = long_normalize(longobjp); */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1386 while (ldcount > 0 && longobjp->ob_digit[ldcount-1] == 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1387 ldcount--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1388 longobjp->ob_size = ldcount;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1389
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1390
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1391 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1392 longobjp->ob_size = -longobjp->ob_size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1393
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1394 return (object *)longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1395
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1396 } /* mpz_long() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1397
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1398
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1399 /* I would have avoided pow() anyways, so ... */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1400 static const double multiplier = 256.0 * 256.0 * 256.0 * 256.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1401
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1402 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1403 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1404 mpz_float(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1405 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1406 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1407 #else /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1408 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1409 mpz_float(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1410 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1411 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1412 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1413 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1414 double x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1415 double mulstate;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1416 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1417
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1418
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1419 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1420 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1421 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1422 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1423
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1424 i = (int)mpz_size(&self->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1425
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1426 /* determine sign, and copy abs(self) to scratch var */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1427 if (isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1428 mpz_init(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1429 mpz_neg(&mpzscratch, &self->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1430 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1431 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1432 mpz_init_set(&mpzscratch, &self->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1433
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1434 /* let those bits come, let those bits go,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1435 e.g. dismantle mpzscratch, build floatobject */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1436
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1437 x = 0.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1438 mulstate = 1.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1439 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1440 x += mulstate * mpz_get_ui(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1441 mulstate *= multiplier;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1442 mpz_div_2exp(&mpzscratch, &mpzscratch, BITS_PER_MP_LIMB);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1443 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1444
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1445 assert(mpz_cmp_ui(&mpzscratch, (unsigned long int)0) == 0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1446 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1447
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1448 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1449 x = -x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1450
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1451 return newfloatobject(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1452
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1453 } /* mpz_float() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1454
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1455 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1456 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1457 mpz_hex(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1458 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1459 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1460 #else /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1461 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1462 mpz_hex(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1463 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1464 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1465 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1466 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1467 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1468 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1469 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1470
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1471 return mpz_format(self, 16, (unsigned char)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1472 } /* mpz_hex() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1473
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1474 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1475 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1476 mpz_oct(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1477 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1478 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1479 #else /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1480 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1481 mpz_oct(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1482 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1483 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1484 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1485 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1486 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1487 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1488 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1489
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1490 return mpz_format(self, 8, (unsigned char)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1491 } /* mpz_oct() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1492
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1493 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1494 mpz_binary(self, args)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1495 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1496 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1497 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1498 int size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1499 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1500 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1501 MP_INT mp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1502 unsigned long ldigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1503
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1504 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1505 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1506
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1507 if (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1508 err_setstr(ValueError, "mpz.binary() arg must be >= 0");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1509 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1510 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1511
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1512 mpz_init_set(&mp, &self->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1513 size = (int)mpz_size(&mp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1514
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1515 if ((strobjp = (stringobject *)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1516 newsizedstringobject((char *)0,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1517 size * sizeof (unsigned long int))) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1518 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1519
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1520 /* get the beginning of the string memory and start copying things */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1521 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1522
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1523 /* this has been programmed using a (fairly) decent lib-i/f it could
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1524 be must faster if we looked into the GMP lib */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1525 while (size--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1526 ldigit = mpz_get_ui(&mp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1527 mpz_div_2exp(&mp, &mp, BITS_PER_MP_LIMB);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1528 *cp++ = (unsigned char)(ldigit & 0xFF);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1529 *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1530 *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1531 *cp++ = (unsigned char)((ldigit >>= 8) & 0xFF);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1532 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1533
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1534 while (strobjp->ob_size && !*--cp)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1535 strobjp->ob_size--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1536
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1537 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1538 } /* mpz_binary() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1539
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1540
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1541 static struct methodlist mpz_methods[] = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1542 #ifdef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1543 {"int", mpz_int},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1544 {"long", mpz_long},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1545 {"float", mpz_float},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1546 {"hex", mpz_hex},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1547 {"oct", mpz_oct},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1548 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1549 {"binary", (object * () (object , object *)) mpz_binary},
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1550 {NULL, NULL} /* sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1551 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1552
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1553 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1554 mpz_getattr(self, name)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1555 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1556 char *name;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1557 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1558 return findmethod(mpz_methods, (object *)self, name);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1559 } /* mpz_getattr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1560
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1561
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1562 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1563 mpz_coerce(pv, pw)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1564 object **pv;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1565 object **pw;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1566 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1567 object *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1568
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1569 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1570 fputs("mpz_coerce() called...\n", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1571 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1572
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1573 assert(is_mpzobject(*pv));
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1574
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1575 /* always convert other arg to mpz value, except for floats */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1576 if (!is_floatobject(*pw)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1577 if ((z = (object )mpz_mpzcoerce(pw)) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1578 return -1; /* -1: an error always has been set */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1579
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1580 INCREF(*pv);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1581 *pw = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1582 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1583 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1584 if ((z = mpz_float(*pv, NULL)) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1585 return -1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1586
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1587 INCREF(*pw);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1588 *pv = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1589 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1590 return 0; /* coercion succeeded */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1591
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1592 } /* mpz_coerce() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1593
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1594
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1595 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1596 mpz_repr(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1597 object *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1598 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1599 return mpz_format(v, 10, (unsigned char)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1600 } /* mpz_repr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1601
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1602
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1603
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1604 #define UF (object* () FPROTO((object ))) /* Unary function */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1605 #define BF (object* () FPROTO((object , object ))) / Binary function */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1606 #define IF (int () FPROTO((object ))) /* Int function */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1607
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1608 static number_methods mpz_as_number = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1609 BF mpz_addition, /nb_add/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1610 BF mpz_substract, /nb_subtract/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1611 BF mpz_multiply, /nb_multiply/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1612 BF mpz_divide, /nb_divide/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1613 BF mpz_remainder, /nb_remainder/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1614 BF mpz_div_and_mod, /nb_divmod/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1615 BF mpz_power, /nb_power/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1616 UF mpz_negative, /nb_negative/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1617 UF mpz_positive, /tp_positive/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1618 UF mpz_absolute, /tp_absolute/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1619 IF mpz_nonzero, /tp_nonzero/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1620 UF mpz_invert, /nb_invert/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1621 BF mpz_lshift, /nb_lshift/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1622 BF mpz_rshift, /nb_rshift/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1623 BF mpz_andfunc, /nb_and/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1624 BF mpz_xorfunc, /nb_xor/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1625 BF mpz_orfunc, /nb_or/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1626 (int () FPROTO((object , object *)))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1627 mpz_coerce, /nb_coerce/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1628 #ifndef MPZ_CONVERSIONS_AS_METHODS
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1629 UF mpz_int, /nb_int/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1630 UF mpz_long, /nb_long/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1631 UF mpz_float, /nb_float/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1632 UF mpz_oct, /nb_oct/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1633 UF mpz_hex, /nb_hex/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1634 #endif /* ndef MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1635 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1636
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1637 static typeobject MPZtype = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1638 OB_HEAD_INIT(&Typetype)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1639 0, /ob_size/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1640 "mpz", /tp_name/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1641 sizeof(mpzobject), /tp_size/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1642 0, /tp_itemsize/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1643 /* methods */
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1644 (void () (object )) mpz_dealloc, /tp_dealloc/
1400 aac8231a715c * mpzmodule.c: removed redundant mpz_print function. Guido van Rossum <guido@python.org> parents: 1132 diff changeset	1645 0, /tp_print/
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1646 (object * ()(object , char )) mpz_getattr, /tp_getattr*/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1647 0, /tp_setattr/
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1648 (int () (object , object )) mpz_compare, /tp_compare*/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1649 mpz_repr, /tp_repr/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1650 &mpz_as_number, /tp_as_number/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1651 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1652
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1653 /* List of functions exported by this module */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1654
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1655 static struct methodlist mpz_functions[] = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1656 #if 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1657 {initialiser_name, MPZ_mpz},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1658 #else /* 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1659 /* until guido ``fixes'' struct methodlist */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1660 {(char *)initialiser_name, MPZ_mpz},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1661 #endif /* 0 else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1662 {"powm", MPZ_powm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1663 {"gcd", MPZ_gcd},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1664 {"gcdext", MPZ_gcdext},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1665 {"sqrt", MPZ_sqrt},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1666 {"sqrtrem", MPZ_sqrtrem},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1667 {"divm", MPZ_divm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1668 {NULL, NULL} /* Sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1669 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1670
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1671
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1672 /* #define MP_TEST_ALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1673
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1674 #ifdef MP_TEST_ALLOC
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1675 #define MP_TEST_SIZE 4
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1676 static const char mp_test_magic[MP_TEST_SIZE] = {'\xAA','\xAA','\xAA','\xAA'};
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1677 static mp_test_error( location )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1678 int *location;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1679 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1680 /* assumptions: *alloc returns address dividable by 4,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1681 mpz_* routines allocate in chunks dividable by four */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1682 fprintf(stderr, "MP_TEST_ERROR: location holds 0x%08d\n", *location );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1683 fatal("MP_TEST_ERROR");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1684 } /* static mp_test_error() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1685 #define MP_EXTRA_ALLOC(size) ((size) + MP_TEST_SIZE)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1686 #define MP_SET_TEST(basep,size) (void)memcpy( ((char *)(basep))+(size), mp_test_magic, MP_TEST_SIZE)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1687 #define MP_DO_TEST(basep,size) if ( !memcmp( ((char *)(basep))+(size), mp_test_magic, MP_TEST_SIZE ) ) \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1688 ; \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1689 else \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1690 mp_test_error((int )((char )(basep) + size))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1691 #else /* def MP_TEST_ALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1692 #define MP_EXTRA_ALLOC(size) (size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1693 #define MP_SET_TEST(basep,size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1694 #define MP_DO_TEST(basep,size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1695 #endif /* def MP_TEST_ALLOC else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1696
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1697 void *mp_allocate( alloc_size )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1698 size_t alloc_size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1699 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1700 void *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1701
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1702 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1703 fprintf(stderr, "mp_allocate : size %ld\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1704 alloc_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1705 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1706
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1707 if ( (res = malloc(MP_EXTRA_ALLOC(alloc_size))) == NULL )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1708 fatal("mp_allocate failure");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1709
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1710 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1711 fprintf(stderr, "mp_allocate : address 0x%08x\n", res);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1712 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1713
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1714 MP_SET_TEST(res,alloc_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1715
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1716 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1717 } /* mp_allocate() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1718
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1719
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1720 void *mp_reallocate( ptr, old_size, new_size )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1721 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1722 size_t old_size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1723 size_t new_size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1724 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1725 void *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1726
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1727 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1728 fprintf(stderr, "mp_reallocate: old address 0x%08x, old size %ld\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1729 ptr, old_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1730 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1731
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1732 MP_DO_TEST(ptr, old_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1733
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1734 if ( (res = realloc(ptr, MP_EXTRA_ALLOC(new_size))) == NULL )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1735 fatal("mp_reallocate failure");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1736
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1737 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1738 fprintf(stderr, "mp_reallocate: new address 0x%08x, new size %ld\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1739 res, new_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1740 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1741
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1742 MP_SET_TEST(res, new_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1743
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1744 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1745 } /* mp_reallocate() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1746
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1747
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1748 void mp_free( ptr, size )
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1749 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1750 size_t size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1751 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1752
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1753 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1754 fprintf(stderr, "mp_free : old address 0x%08x, old size %ld\n",
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1755 ptr, size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1756 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1757
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1758 MP_DO_TEST(ptr, size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1759 free(ptr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1760 } /* mp_free() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1761
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1762
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1763
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1764 /* Initialize this module. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1765
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1766 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1767 initmpz()
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1768 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1769 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1770 fputs( "initmpz() called...\n", stderr );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1771 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1772
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1773 mp_set_memory_functions( mp_allocate, mp_reallocate, mp_free );
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1774 (void)initmodule("mpz", mpz_functions);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1775
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1776 /* create some frequently used constants */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1777 if ((mpz_value_zero = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1778 fatal("initmpz: can't initialize mpz contstants");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1779 mpz_set_ui(&mpz_value_zero->mpz, (unsigned long int)0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1780
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1781 if ((mpz_value_one = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1782 fatal("initmpz: can't initialize mpz contstants");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1783 mpz_set_ui(&mpz_value_one->mpz, (unsigned long int)1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1784
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1785 if ((mpz_value_mone = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1786 fatal("initmpz: can't initialize mpz contstants");
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1787 mpz_set_si(&mpz_value_mone->mpz, (long)-1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1788
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1789 } /* initmpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1790 #ifdef MAKEDUMMYINT
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1791 int _mpz_dummy_int; /* XXX otherwise, we're .bss-less (DYNLOAD->Jack?) */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1792 #endif /* def MAKEDUMMYINT */

Mercurial > cpython-lru_cache-weakref

annotate Modules/mpzmodule.c @ 1590:ac2e5cc29949 legacy-trunk