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

annotate Modules/mpzmodule.c @ 3216:d00a79ebb027 legacy-trunk

Added missing imgpbm and imgsgi modules

author	Jack Jansen <jack.jansen@cwi.nl>
date	Thu, 12 Oct 1995 10:23:27 +0000
parents	56ca67ddec85
children	ef6c89fe21ed

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 /***********************************************************
2061 172ba04a5191 Added 1995 to copyright message. Guido van Rossum <guido@python.org> parents: 2055 diff changeset	2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
172ba04a5191 Added 1995 to copyright message. Guido van Rossum <guido@python.org> parents: 2055 diff changeset	3 The Netherlands.
1132 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 ******************************************************************/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	24
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	25 /* MPZ module */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	26
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	27 /* 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	28 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	29
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	30 /* 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	31 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	32
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	33
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	34 /* MPZ objects */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	35
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	36 #include "allobjects.h"
2123 fd5ab7e828fc cosmetic changes so these modules will work with the strict new naming scheme Guido van Rossum <guido@python.org> parents: 2061 diff changeset	37
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	38 #include <assert.h>
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	39 #include <sys/types.h> /* For size_t */
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	40
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 ** 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	43 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	44 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	45 ** 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	46 ** 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	47 ** GMP.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	48 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	49 ** 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	50 ** 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	51 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	52 ** 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	53 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	54 ** 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	55 ** 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	56 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	57 ** 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	58 ** routines are involved
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	59 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	60 ** 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	61 ** 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	62 ** integral type).
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	63 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	64 ** 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	65 ** 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	66 ** 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	67 ** 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	68 ** 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	69 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	70 ** 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	71 ** is needed
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 ** 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	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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	77 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	78 ** 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	79 ** 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	80 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	81 /#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	82 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	83 ** 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	84 ** allocate it himself
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 #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	87
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	88 #include "gmp.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	89 typedef struct {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	90 OB_HEAD
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	91 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	92 } mpzobject;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	93
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	94 staticforward typeobject MPZtype;
1132 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 #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	97
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	98 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	99
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	100 /* #define MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	101
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	102 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	103 newmpzobject()
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 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	106
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	107
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	108 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	109 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	110 #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	111 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	112 if (mpzp == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	113 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	114
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	115 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	116 return mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	117 } /* newmpzobject() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	118
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	119 #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	120 #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	121 #include "longlong.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	122 #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	123
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	124 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	125 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	126 object *objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	127 int base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	128 unsigned char withname;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	129 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	130 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	131 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	132 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	133 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	134 int taglong;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	135 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	136 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	137
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 tcp = &prefix[0];
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	140
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	141 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	142 err_badcall();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	143 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	144 }
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 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	147
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	148 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	149 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	150 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	151 i = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	152
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	153 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	154 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	155 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	156 *tcp++ = '-';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	157 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	158 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	159
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	160 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	161 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	162 (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	163 #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	164 #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	165 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	166 * __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	167 #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	168 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	169 #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	170
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	171 if (base == 16) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	172 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	173 *tcp++ = 'x';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	174 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	175 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	176 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	177 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	178 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	179 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	180 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	181 *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	182 *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	183 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	184 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	185 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	186 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	187 *tcp++ = '0' + base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	188 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	189 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	190 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	191
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	192 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	193 ** 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	194 ** 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	195 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	196 taglong = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	197 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	198 \|\| (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	199 taglong = 1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	200 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	201 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	202
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	203 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	204 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	205 #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	206 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	207 == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	208 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	209
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	210 /* 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	211 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	212 if (withname) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	213 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	214 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	215 cp++ = '('; /')'*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	216 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	217
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	218 /* 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	219 *tcp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	220 strcpy(cp, prefix);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	221 cp += tcp - prefix;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	222
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	223 /* 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	224 number */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	225 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	226 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	227 (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	228 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	229 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	230 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	231 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	232 base, cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	233 #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	234 cp += strlen(cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	235
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	236 if (taglong)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	237 *cp++ = 'L';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	238 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	239 cp++ = /'('*/ ')';
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 *cp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	242
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	243 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	244 fprintf(stderr,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	245 "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	246 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	247 #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	248 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	249
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	250 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	251 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	252 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	253
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	254 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	255 } /* mpz_format() */
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 /* MPZ methods */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	258
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	259 static void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	260 mpz_dealloc(mpzp)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	261 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	262 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	263 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	264 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	265 #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	266 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	267 DEL(mpzp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	268 } /* mpz_dealloc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	269
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	270
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	271 /* 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	272 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	273
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	274 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	275 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	276 mpzobject a, b;
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 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	279
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	280
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	281 /* 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	282 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	283 : 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	284 } /* mpz_compare() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	285
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	286 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	287 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	288 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	289 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	292
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	293
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	294 #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	295 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	296 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	297 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	298 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	299
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	300 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	301 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	302 return (object *)a;
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 #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	305
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	306 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	307 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	308
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	309 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	310 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	311 } /* mpz_addition() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	312
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	313 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	314 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	315 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	316 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	319
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	320
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	321 #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	322 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	323 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	324 return (object *)a;
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 #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	327
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	328 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	329 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	330
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	331 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	332 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	333 } /* mpz_substract() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	334
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	335 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	336 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	337 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	338 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	339 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	340 #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	341 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	342 #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	343 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	344
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	345
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	346 #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	347 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	348 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	349 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	350 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	351 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	352 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	353 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	354 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	355
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	356 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	357 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	358 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	359 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	360 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	361 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	362 return (object *)a;
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 #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	365
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	366 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	367 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	368
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	369 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	370 return (object *)z;
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 } /* mpz_multiply() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	373
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	374 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	375 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	376 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	377 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	378 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	379 #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	380 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	381 #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	382 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	383
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	384
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	385 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	386 #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	387 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	388 #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	389 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	390 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	391 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	392 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	393 #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	394 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	395 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	396 return (object *)a;
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 #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	399
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	400 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	401 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	402
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	403 #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	404 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	405 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	406 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	407 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	408 #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	409 #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	410 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	411 != (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	412 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	413 ** 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	414 ** 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	415 ** 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	416 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	417 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	418
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	419
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	420 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	421 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	422
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	423 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	424 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	425
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	426 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	427 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	428 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	429 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	430 /* 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	431 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	432
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	433 #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	434 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	435 #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	436 #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	437 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	438 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	439 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	440 #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	441 return (object *)z;
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 } /* mpz_divide() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	444
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	445 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	446 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	447 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	448 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	449 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	450 #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	451 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	452 #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	453 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	454
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	455
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	456 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	457 #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	458 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	459 #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	460 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	461 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	462 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	463 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	464 #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	465 if (cmpres > 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	466 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	467 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	468 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	469 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	470 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	471 /* 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	472 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	473 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	474 }
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 #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	477
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	478 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	479 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	480
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	481 #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	482 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	483 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	484 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	485 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	486 #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	487 #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	488
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	489 /* 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	490 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	491 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	492
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	493 /* 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	494 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	495 != (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	496 && 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	497 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	498 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	499 ** 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	500 ** 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	501 ** 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	502 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	503 #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	504 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	505 #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	506 #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	507 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	508 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	509 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	510 #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	511 return (object *)z;
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 } /* mpz_remainder() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	514
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	515 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	516 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	517 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	518 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	519 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	520 object *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	521 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	522
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	523
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	524 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	525 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	526 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	527 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	528
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	529 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	530 \|\| (x = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	531 \|\| (y = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	532 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	533 XDECREF(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	534 XDECREF(y);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	535 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	536 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	537
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	538 #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	539 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	540 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	541 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	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 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	544 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	545 #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	546 #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	547 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	548 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	549 != (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	550 && 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	551 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	552 ** 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	553 ** 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	554 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	555 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	556 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	557 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	558 #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	559 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	560 #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	561 #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	562 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	563 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	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 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	566 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	567 #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	568
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	569 (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	570 (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	571
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	572 return z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	573 } /* 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	574
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	575 static object *
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	576 mpz_power(a, b, m)
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	577 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	578 mpzobject *b;
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	579 mpzobject *m;
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	580 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	581 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	582 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	583 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	584
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	585 if ((object *)m!=Py_None)
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	586 {
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	587 mpzobject *z2;
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	588 INCREF(Py_None);
2309 56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	589 z=(mpzobject )mpz_power(a, b, (mpzobject )Py_None);
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	590 DECREF(Py_None);
2309 56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	591 if (z==NULL) return((object *)z);
56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	592 z2=(mpzobject *)mpz_remainder(z, m);
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	593 DECREF(z);
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	594 return((object *)z2);
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	595 }
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	596
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	597 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	598 /* 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	599
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	600 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	601 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	602 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	603
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	604 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	605 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	606 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	609 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	610 /* 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	611
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	612 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	613 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	614 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	615 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	616 && 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	617 /* 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	618
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	619 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	620 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	621 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	622 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	623 && 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	624
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	625 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	626 /* 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	627 /* 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	628 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	629 for unobvious reasons */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	630
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	631 /* 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	632 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	633
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	634 /* 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	635 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	636
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	637 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	638 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	639 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	640 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	641 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	642 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	643 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	644 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	645 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	646
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	647 #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	648 /* 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	649 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	650 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	651 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	652 #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	653 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	654 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	655 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	656 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	657 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	658 #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	659
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	660 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	661 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	662
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	663 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	664
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	665 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	666 } /* mpz_power() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	669 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	670 mpz_negative(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	671 mpzobject *v;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	674
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	675
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	676 #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	677 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	678 /* -0 == 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	679 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	680 return (object *)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 #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	683
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	684 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	685 return NULL;
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 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	688 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	689 } /* mpz_negative() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	692 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	693 mpz_positive(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	694 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	695 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	696 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	697 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	698 } /* mpz_positive() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	699
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	700
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	701 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	702 mpz_absolute(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	703 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	704 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	705 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	706
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	707
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	708 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	709 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	710 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	711 }
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 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	714 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	715
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	716 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	717 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	718 } /* mpz_absolute() */
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 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	721 mpz_nonzero(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	722 mpzobject *v;
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 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	725 } /* mpz_nonzero() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	726
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	727 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	728 mpz_invert(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	729 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	730 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	731 mpzobject *z;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	734 /* 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	735 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	736 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	737
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	738 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	739 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	740 } /* mpz_invert() */
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	743 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	744 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	745 mpzobject *b;
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 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	748 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	749
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	750
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	751 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	752 /* a << 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	753 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	754 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	755 }
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 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	758 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	759 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	760 }
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 #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	763 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	764 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	765 #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	766 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	767 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	768 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	769 return NULL;
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 #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	772
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	773 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	774 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	775
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	776 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	777 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	778 } /* mpz_lshift() */
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	781 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	782 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	783 mpzobject *b;
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 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	786 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	787
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 ((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	790 /* a >> 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	791 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	792 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	793 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	794
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	795 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	796 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	797 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	798 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	799
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	800 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	801 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	802
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	803 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	804 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	805
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	806 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	807 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	808 } /* mpz_rshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	809
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	810 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	811 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	812 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	813 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	814 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	815 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	816
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 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	819 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	820
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	821 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	822 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	823 } /* mpz_andfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	824
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	825 /* 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	826 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	827 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	828 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	829 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	830 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	831 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	832 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	833
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	834 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	835
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	836 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	837 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	838 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	839 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	840
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	841 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	842 } /* mpz_xor() HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	843
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	844 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	845 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	846 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	847 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	848 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	849 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	850
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 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	853 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	854
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	855 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	856 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	857 } /* mpz_xorfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	858
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	859 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	860 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	861 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	862 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	865
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	866
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	867 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	868 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	869
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	870 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	871 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	872 } /* mpz_orfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	873
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	874 /* MPZ initialisation */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	875
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	876 #include "longintrepr.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	877
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	878 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	879 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	880 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	881 object *args;
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 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	884 object *objp;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	887 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	888 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	889 #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	890
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	891 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	892 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	893
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	894 /* 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	895 /* 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	896
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	897 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	898 long lval;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	899
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	900 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	901 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	902
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	903 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	904 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	905 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	906 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	907 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	908 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	909 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	910 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	911 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	912 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	913 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	914 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	915 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	916 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	917 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	918 unsigned char isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	919
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	920
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	921 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	922 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	923
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	924 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	925 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	926
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	927 /* 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	928 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	929 i = -i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	930
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	931 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	932 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	933 (unsigned long)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	934 ((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	935 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	936 (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	937 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	938 }
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 (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	941 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	942
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	943 /* 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	944 mpz_clear(&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 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	947 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	948 int len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	949 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	950
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	951 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	952 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	953
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	954 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	955 return NULL;
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 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	958 mpz_init(&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 /* 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	961 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	962
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	963 cp += len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	964 while (len--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	965 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	966 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	967 (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	968 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	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 /* 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	972 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	973 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	974 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	975 INCREF(objp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	976 mpzp = (mpzobject *)objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	977 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	978 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	979 err_setstr(TypeError,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	980 "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	981 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	984
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	985 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	986 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	987 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	988 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	989 #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	990 return (object *)mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	991 } /* MPZ_mpz() */
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 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	994 mpz_mpzcoerce(z)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	995 object *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	996 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	997 /* 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	998 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	999 INCREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1000 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	1001 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1002
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1003 /* 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	1004 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	1005 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	1006
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1007 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	1008 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1009 } /* mpz_mpzcoerce() */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1010
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1011 /* Forward */
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1012 static void mpz_divm PROTO((MP_INT res, const MP_INT num,
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1013 const MP_INT den, const MP_INT mod));
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1014
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1015 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1016 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	1017 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1018 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1019 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1020 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	1021 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	1022 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1023 int tstres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1024
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1025
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1026 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	1027 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1028
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1029 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	1030 \|\| (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	1031 \|\| (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	1032 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1033 XDECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1034 XDECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1035 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1036 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1039 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	1040 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	1041 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	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 if (tstres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1045 MP_INT absexp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1046 /* negative exp */
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 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	1049 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	1050 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	1051
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1052 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	1053
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1054 mpz_clear(&absexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1055 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1056 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1057 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	1058 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1059
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1060 DECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1061 DECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1062 DECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1063
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1064 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1065 } /* MPZ_powm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1066
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1067
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1068 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1069 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	1070 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1071 object *args;
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 object op1, op2;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1074 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	1075 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1076
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1077
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1078 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	1079 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1080
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1081 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	1082 \|\| (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	1083 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1084 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1085 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1086 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1089 /* 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	1090 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	1091
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1092 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1093 DECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1094
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1095 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1096 } /* MPZ_gcd() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1097
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1098
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1099 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1100 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	1101 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1102 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1103 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1104 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	1105 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	1106 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	1107
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1108
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1109 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	1110 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1111
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1112 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	1113 \|\| (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	1114 \|\| (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	1115 \|\| (g = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1116 \|\| (s = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1117 \|\| (t = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1118 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1119 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1120 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1121 XDECREF(g);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1122 XDECREF(s);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1123 /XDECREF(t);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1124 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1125 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1126
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1127 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	1128
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1129 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1130 DECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1131
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1132 (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	1133 (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	1134 (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	1135
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1136 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1137 } /* MPZ_gcdext() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1138
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1139
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1140 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1141 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	1142 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1143 object *args;
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 object *op;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1146 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1147 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1148
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 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	1151 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1152
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1153 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	1154 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1155 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1156 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1157 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1158
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1159 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	1160
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1161 DECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1162
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1163 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1164 } /* MPZ_sqrt() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1165
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1166
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1167 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1168 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	1169 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1170 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1171 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1172 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	1173 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1174 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	1175
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 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	1178 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1179
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1180 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	1181 \|\| (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	1182 \|\| (root = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1183 \|\| (rem = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1184 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1185 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1186 XDECREF(root);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1187 /XDECREF(rem);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1188 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1189 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1190
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1191 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	1192
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1193 DECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1194
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1195 (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	1196 (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	1197
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1198 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1199 } /* MPZ_sqrtrem() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1200
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1201
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1202 static void
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1203 #if __STDC__
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1204 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	1205 #else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1206 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	1207 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1208 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	1209 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	1210 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	1211 #endif
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1212 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1213 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	1214
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1215 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	1216 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	1217 mpz_init(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1218 mpz_init(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1219 mpz_init(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1220 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	1221 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	1222
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1223 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	1224 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	1225 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	1226 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	1227
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1228 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	1229 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	1230 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	1231 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	1232 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1233
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1234 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	1235 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	1236 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1237 #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	1238 /* 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	1239 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	1240 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	1241 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	1242
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1243 if (res->size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1244 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	1245 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1246 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1247 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	1248
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1249 #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	1250 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	1251 #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	1252 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1253
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1254 mpz_clear(&s0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1255 mpz_clear(&s1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1256 mpz_clear(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1257 mpz_clear(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1258 mpz_clear(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1259 mpz_clear(&d0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1260 mpz_clear(&d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1261 } /* mpz_divm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1262
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1263
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1264 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1265 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	1266 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1267 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1268 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1269 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	1270 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	1271 mpzobject *z = NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1274 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	1275 return NULL;
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 ((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	1278 \|\| (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	1279 \|\| (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	1280 \|\| (z = newmpzobject()) == NULL ) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1281 XDECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1282 XDECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1283 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1284 return NULL;
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_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	1288
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1289 DECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1290 DECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1291 DECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1292
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1293 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	1294 DECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1295 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	1296 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1297 }
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 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1300 } /* MPZ_divm() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1303 /* 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	1304 #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	1305 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1306 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	1307 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1308 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1309 #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	1310 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1311 mpz_int(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1312 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1313 #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	1314 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1315 long sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1316
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1317
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1318 #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	1319 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1320 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1321 #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	1322
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1323 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	1324 \|\| (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	1325 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	1326 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1327 }
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 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	1330 sli = -sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1331
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1332 return newintobject(sli);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1333 } /* mpz_int() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1334
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1335 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1336 #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	1337 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	1338 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1339 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1340 #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	1341 mpz_long(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1342 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1343 #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	1344 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1345 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1346 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	1347 longobject *longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1348 int ldcount;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1349 int bitpointer, newbitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1350 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1351
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1352
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1353 #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	1354 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1355 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1356 #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	1357
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1358 /* 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	1359 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	1360 ((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	1361 + SHIFT - 1) /
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1362 SHIFT))) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1363 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1364
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1365 /* 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	1366 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	1367 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	1368 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	1369
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1370 /* 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	1371 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	1372
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1373 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	1374 newbitpointer = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1375 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	1376 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	1377 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1378 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	1379
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1380 /* 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	1381 if (bitpointer < SHIFT) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1382 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	1383 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	1384 (uli << bitpointer) & MASK;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1385 uli >>= SHIFT-bitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1386 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	1387 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	1388 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	1389 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1390 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1391 uli >>= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1392 bitpointer -= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1393 ldcount++;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1394 }
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 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	1397 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1398 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	1399
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1400 /* 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	1401 /* 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	1402 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	1403 ldcount--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1404 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	1405
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1406
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1407 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1408 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	1409
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1410 return (object *)longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1411
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1412 } /* mpz_long() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1413
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1414
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1415 /* 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	1416 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	1417
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1418 #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	1419 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1420 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	1421 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1422 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1423 #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	1424 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1425 mpz_float(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1426 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1427 #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	1428 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1429 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1430 double x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1431 double mulstate;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1432 MP_INT mpzscratch;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1435 #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	1436 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1437 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1438 #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	1439
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1440 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	1441
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1442 /* 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	1443 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	1444 mpz_init(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1445 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	1446 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1447 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1448 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	1449
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1450 /* 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	1451 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	1452
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1453 x = 0.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1454 mulstate = 1.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1455 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1456 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	1457 mulstate *= multiplier;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1458 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	1459 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1460
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1461 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	1462 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1463
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1464 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1465 x = -x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1466
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1467 return newfloatobject(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1468
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1469 } /* mpz_float() */
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 #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	1472 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1473 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	1474 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1475 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1476 #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	1477 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1478 mpz_hex(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1479 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1480 #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	1481 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1482 #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	1483 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1484 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1485 #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	1486
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1487 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	1488 } /* mpz_hex() */
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 #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	1491 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1492 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	1493 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1494 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1495 #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	1496 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1497 mpz_oct(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1498 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1499 #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	1500 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1501 #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	1502 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1503 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1504 #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	1505
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1506 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	1507 } /* mpz_oct() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1508
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1509 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1510 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	1511 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1512 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1513 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1514 int size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1515 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1516 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1517 MP_INT mp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1518 unsigned long ldigit;
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 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1521 return NULL;
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 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	1524 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	1525 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1526 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1527
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1528 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	1529 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	1530
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1531 if ((strobjp = (stringobject *)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1532 newsizedstringobject((char *)0,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1533 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	1534 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1535
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1536 /* 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	1537 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1538
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1539 /* 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	1540 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	1541 while (size--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1542 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	1543 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	1544 *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	1545 *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	1546 *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	1547 *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	1548 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1549
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1550 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	1551 strobjp->ob_size--;
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 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1554 } /* mpz_binary() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1555
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1556
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1557 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	1558 #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	1559 {"int", mpz_int},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1560 {"long", mpz_long},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1561 {"float", mpz_float},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1562 {"hex", mpz_hex},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1563 {"oct", mpz_oct},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1564 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1565 {"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	1566 {NULL, NULL} /* sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1567 };
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1570 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	1571 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1572 char *name;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1573 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1574 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	1575 } /* mpz_getattr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1576
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1577
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1578 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1579 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	1580 object **pv;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1581 object **pw;
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 object *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1584
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1585 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1586 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	1587 #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	1588
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1589 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	1590
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1591 /* 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	1592 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	1593 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	1594 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	1595
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1596 INCREF(*pv);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1597 *pw = z;
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 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1600 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	1601 return -1;
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 INCREF(*pw);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1604 *pv = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1605 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1606 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	1607
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1608 } /* mpz_coerce() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1609
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1610
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1611 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1612 mpz_repr(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1613 object *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1614 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1615 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	1616 } /* mpz_repr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1617
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1618
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1619
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1620 #define UF (unaryfunc)
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1621 #define BF (binaryfunc)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1622 #define TF (ternaryfunc)
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1623 #define IF (inquiry)
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1624 #define CF (coercion)
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1625
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1626 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	1627 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	1628 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	1629 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	1630 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	1631 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	1632 BF mpz_div_and_mod, /nb_divmod/
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1633 TF mpz_power, /nb_power/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1634 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	1635 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	1636 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	1637 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	1638 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	1639 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	1640 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	1641 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	1642 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	1643 BF mpz_orfunc, /nb_or/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1644 CF mpz_coerce, /nb_coerce/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1645 #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	1646 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	1647 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	1648 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	1649 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	1650 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	1651 #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	1652 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1653
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1654 static typeobject MPZtype = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1655 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	1656 0, /ob_size/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1657 "mpz", /tp_name/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1658 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	1659 0, /tp_itemsize/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1660 /* methods */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1661 (destructor)mpz_dealloc, /tp_dealloc/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1662 0, /tp_print/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1663 (getattrfunc)mpz_getattr, /tp_getattr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1664 0, /tp_setattr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1665 (cmpfunc)mpz_compare, /tp_compare/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1666 (reprfunc)mpz_repr, /tp_repr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1667 &mpz_as_number, /tp_as_number/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1668 };
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 /* 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	1671
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1672 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	1673 #if 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1674 {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	1675 #else /* 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1676 /* 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	1677 {(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	1678 #endif /* 0 else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1679 {"powm", MPZ_powm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1680 {"gcd", MPZ_gcd},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1681 {"gcdext", MPZ_gcdext},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1682 {"sqrt", MPZ_sqrt},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1683 {"sqrtrem", MPZ_sqrtrem},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1684 {"divm", MPZ_divm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1685 {NULL, NULL} /* Sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1686 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1687
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 /* #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	1690
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1691 #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	1692 #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	1693 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	1694 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	1695 int *location;
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 /* 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	1698 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	1699 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	1700 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	1701 } /* 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	1702 #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	1703 #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	1704 #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	1705 ; \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1706 else \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1707 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	1708 #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	1709 #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	1710 #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	1711 #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	1712 #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	1713
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1714 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	1715 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	1716 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1717 void *res;
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1720 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	1721 alloc_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1722 #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	1723
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1724 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	1725 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	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_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	1729 #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	1730
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1731 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	1732
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1733 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1734 } /* mp_allocate() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1735
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 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	1738 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1739 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	1740 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	1741 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1742 void *res;
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1745 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	1746 ptr, old_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1747 #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	1748
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1749 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	1750
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1751 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	1752 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	1753
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1754 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1755 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	1756 res, new_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1757 #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	1758
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1759 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	1760
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1761 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1762 } /* mp_reallocate() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1765 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	1766 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1767 size_t size;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1770 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1771 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	1772 ptr, size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1773 #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	1774
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1775 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	1776 free(ptr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1777 } /* mp_free() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1778
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1779
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 /* Initialize this module. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1782
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1783 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1784 initmpz()
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1785 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1786 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1787 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	1788 #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	1789
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1790 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	1791 (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	1792
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1793 /* 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	1794 if ((mpz_value_zero = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1795 fatal("initmpz: can't initialize mpz constants");
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1796 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	1797
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1798 if ((mpz_value_one = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1799 fatal("initmpz: can't initialize mpz constants");
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1800 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	1801
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1802 if ((mpz_value_mone = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1803 fatal("initmpz: can't initialize mpz constants");
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1804 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	1805
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1806 } /* initmpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1807 #ifdef MAKEDUMMYINT
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1808 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	1809 #endif /* def MAKEDUMMYINT */

Mercurial > cpython-lru_cache-weakref

annotate Modules/mpzmodule.c @ 3216:d00a79ebb027 legacy-trunk