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

annotate Modules/mpzmodule.c @ 4566:6403c94de50d legacy-trunk

Added safeguard against failure in __del__.

author	Guido van Rossum <guido@python.org>
date	Wed, 27 Nov 1996 19:39:58 +0000
parents	65d2d8e67da3
children	f4ba9e07d9bf

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
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	7 Permission to use, copy, modify, and distribute this software and its
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	8 documentation for any purpose and without fee is hereby granted,
1132 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
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	10 both that copyright notice and this permission notice appear in
1132 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
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	12 Centrum or CWI or Corporation for National Research Initiatives or
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	13 CNRI not be used in advertising or publicity pertaining to
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	14 distribution of the software without specific, written prior
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	15 permission.
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	16
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	17 While CWI is the initial source for this software, a modified version
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	18 is made available by the Corporation for National Research Initiatives
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	19 (CNRI) at the Internet address ftp://ftp.python.org.
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	20
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 4052 diff changeset	28 PERFORMANCE OF THIS SOFTWARE.
1132 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 ******************************************************************/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	31
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	32 /* MPZ module */
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 /* 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	35 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	36
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	37 /* 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	38 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	39
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 /* MPZ objects */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	42
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	43 #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	44
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	45 #include <assert.h>
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	46 #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	47
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 ** 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	50 **
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_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	53 ** 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	54 ** GMP.
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	55 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	56 ** 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	57 ** 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	58 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	59 ** 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	60 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	61 ** 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	62 ** 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	63 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	64 ** 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	65 ** routines are involved
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	66 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	67 ** 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	68 ** 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	69 ** integral type).
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	70 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	71 ** 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	72 ** 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	73 ** 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	74 ** 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	75 ** 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	76 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	77 ** 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	78 ** is needed
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	79 **
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	80 ** 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	81 */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	84 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	85 ** IMHO, mpz_m{div,mod,divmod}() do the wrong things when the denominator < 0
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	86 ** This has been fixed with gmp release 2.0
1132 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 /#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	89 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	90 ** 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	91 ** allocate it himself
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	92 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	93
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	94 #include "gmp.h"
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	95 #include "gmp-impl.h"
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	96
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	97 #if __GNU_MP__ == 2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	98 #define GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	99 #else
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	100 #define MPZ_GET_STR_BUG
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	101 #endif
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	102
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	103 typedef struct {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	104 OB_HEAD
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	105 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	106 } mpzobject;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	107
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	108 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	109
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	110 #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	111
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	112 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	113
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	114 /* #define MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	115
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	116 static mpzobject *
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 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	120
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	121
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	122 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	123 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	124 #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	125 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	126 if (mpzp == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	127 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	128
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	129 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	130 return mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	131 } /* newmpzobject() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	133 #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	134 #include "longlong.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	135 #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	136
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	137 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	138 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	139 object *objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	140 int base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	141 unsigned char withname;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	142 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	143 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	144 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	145 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	146 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	147 int taglong;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	148 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	149 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	150
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	151
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	152 tcp = &prefix[0];
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	153
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	154 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	155 err_badcall();
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	156 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	157 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	158
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	159 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	160
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	161 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	162 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	163 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	164 i = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	165
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	166 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	167 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	168 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	169 *tcp++ = '-';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	170 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	171 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	172
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	173 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	174 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	175 (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	176 #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	177 #ifdef MPZ_GET_STR_BUG
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	178 #ifdef GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	179 i += ((size_t) abs(mpzp->mpz._mp_size) * BITS_PER_MP_LIMB
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	180 * __mp_bases[base].chars_per_bit_exactly) + 1;
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	181 #else
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	182 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	183 * __mp_bases[base].chars_per_bit_exactly) + 1;
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	184 #endif
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	185 #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	186 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	187 #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	188
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	189 if (base == 16) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	190 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	191 *tcp++ = 'x';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	192 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	193 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	194 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	195 *tcp++ = '0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	196 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	197 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	198 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	199 *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	200 *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	201 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	202 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	203 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	204 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	205 *tcp++ = '0' + base;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	206 *tcp++ = '#';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	207 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	208 }
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 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	211 ** 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	212 ** 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	213 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	214 taglong = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	215 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	216 \|\| (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	217 taglong = 1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	218 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	219 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	220
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	221 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	222 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	223 #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	224 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	225 == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	226 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	227
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	228 /* 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	229 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	230 if (withname) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	231 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	232 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	233 cp++ = '('; /')'*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	234 }
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 /* 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	237 *tcp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	238 strcpy(cp, prefix);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	239 cp += tcp - prefix;
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 /* 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	242 number */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	243 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	244 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	245 (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	246 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	247 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	248 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	249 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	250 base, cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	251 #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	252 cp += strlen(cp);
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 if (taglong)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	255 *cp++ = 'L';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	256 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	257 cp++ = /'('*/ ')';
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 *cp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	260
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	261 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	262 fprintf(stderr,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	263 "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	264 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	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 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	267
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	268 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	269 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	270 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	271
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	272 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	273 } /* mpz_format() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	274
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	275 /* MPZ methods */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	276
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	277 static void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	278 mpz_dealloc(mpzp)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	279 mpzobject *mpzp;
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	282 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	283 #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	284 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	285 DEL(mpzp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	286 } /* mpz_dealloc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	287
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	288
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	289 /* 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	290 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	291
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	292 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	293 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	294 mpzobject a, b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	295 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	296 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	297
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	298
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	299 /* 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	300 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	301 : 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	302 } /* mpz_compare() */
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	305 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	306 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	307 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	310
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	311
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	312 #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	313 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	314 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	315 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	316 }
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 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	319 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	320 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	321 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	322 #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	323
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	324 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	325 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	326
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	327 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	328 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	329 } /* mpz_addition() */
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	332 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	333 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	334 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	335 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	336 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	337
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	338
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	339 #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	340 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	341 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	342 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	343 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	344 #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	345
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	346 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	347 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	348
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	349 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	350 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	351 } /* mpz_substract() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	352
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	353 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	354 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	355 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	356 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	357 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	358 #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	359 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	360 #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	361 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	362
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 #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	365 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	366 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	367 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	368 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	369 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	370 INCREF(b);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	371 return (object *)b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	372 }
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 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	375 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	376 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	377 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	378 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	379 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	380 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	381 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	382 #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	383
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	384 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	385 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	386
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	387 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	388 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	389
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	390 } /* mpz_multiply() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	391
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	392 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	393 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	394 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	395 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	396 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	397 #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	398 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	399 #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	400 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	401
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 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	404 #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	405 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	406 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	407 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	408 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	409 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	410 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	411 #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	412 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	413 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	414 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	415 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	416 #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	417
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	418 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	419 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	420
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	421 #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	422 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	423 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	424 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	425 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	426 #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	427 #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	428 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	429 != (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	430 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	431 ** 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	432 ** 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	433 ** 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	434 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	435 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	436
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	437
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	438 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	439 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	440
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	441 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	442 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	443
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	444 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	445 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	446 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	447 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	448 /* 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	449 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	450
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	451 #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	452 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	453 #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	454 #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	455 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	456 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	457 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	458 #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	459 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	460
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	461 } /* mpz_divide() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	462
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	463 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	464 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	465 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	466 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	467 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	468 #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	469 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	470 #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	471 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	472
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	473
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	474 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	475 #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	476 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	477 #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	478 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	479 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	480 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	481 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	482 #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	483 if (cmpres > 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	484 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	485 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	486 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	487 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	488 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	489 /* 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	490 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	491 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	492 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	493 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	494 #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	495
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	496 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	497 return NULL;
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 #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	500 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	501 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	502 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	503 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	504 #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	505 #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	506
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	507 /* 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	508 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	509 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	510
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	511 /* 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	512 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	513 != (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	514 && 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	515 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	516 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	517 ** 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	518 ** 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	519 ** 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	520 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	521 #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	522 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	523 #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	524 #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	525 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	526 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	527 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	528 #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	529 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	530
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	531 } /* mpz_remainder() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	532
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	533 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	534 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	535 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	536 mpzobject *b;
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 object *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	539 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	540
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	541
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	542 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	543 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	544 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	545 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	546
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	547 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	548 \|\| (x = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	549 \|\| (y = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	550 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	551 XDECREF(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	552 XDECREF(y);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	553 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	556 #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	557 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	558 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	559 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	560 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	561 mpz_out_str(stderr, 10, &y->mpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	562 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	563 #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	564 #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	565 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	566 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	567 != (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	568 && 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	569 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	570 ** 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	571 ** 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	572 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	573 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	574 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	575 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	576 #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	577 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	578 #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	579 #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	580 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	581 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	582 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	583 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	584 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	585 #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	586
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	587 (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	588 (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	589
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	590 return z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	591 } /* 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	592
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	593 static object *
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	594 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	595 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	596 mpzobject *b;
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	597 mpzobject *m;
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	598 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	599 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	600 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	601
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	602 if ((object *)m!=Py_None)
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	603 {
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	604 mpzobject *z2;
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	605 INCREF(Py_None);
2309 56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	606 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	607 DECREF(Py_None);
2309 56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	608 if (z==NULL) return((object *)z);
56ca67ddec85 add some casts Guido van Rossum <guido@python.org> parents: 2123 diff changeset	609 z2=(mpzobject *)mpz_remainder(z, m);
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	610 DECREF(z);
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	611 return((object *)z2);
cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	612 }
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	613
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	614 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	615 /* 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	616
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	617 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	618 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	619 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	620
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	621 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	622 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	623 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	626 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	627 /* 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	628
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	629 INCREF(mpz_value_zero);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	630 return (object *)mpz_value_zero;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	631 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	632 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	633 && 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	634 /* 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	635
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	636 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	637 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	638 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	639 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	640 && 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	641
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	642 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	643 /* 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	644 /* 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	645 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	646 for unobvious reasons */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	647
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	648 /* 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	649 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	650
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	651 /* 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	652 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	653
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(&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	655 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	656 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	657 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	658 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	659 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	660 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	661 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	662 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	663
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	664 #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	665 /* 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	666 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	667 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	668 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	669 #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	670 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	671 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	672 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	673 return NULL;
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 #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	676
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	677 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	678 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	679
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	680 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	681
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	682 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	683 } /* mpz_power() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	684
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	685
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	686 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	687 mpz_negative(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	688 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	689 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	690 mpzobject *z;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	693 #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	694 if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) == 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	695 /* -0 == 0 */
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 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	699 #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	700
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	701 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	702 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	703
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	704 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	705 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	706 } /* mpz_negative() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	709 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	710 mpz_positive(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	711 mpzobject *v;
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 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	714 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	715 } /* mpz_positive() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	716
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	717
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	718 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	719 mpz_absolute(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	720 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	721 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	722 mpzobject *z;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	725 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	726 INCREF(v);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	727 return (object *)v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	728 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	729
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	730 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	731 return NULL;
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 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	734 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	735 } /* mpz_absolute() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	736
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	737 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	738 mpz_nonzero(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	739 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	740 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	741 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	742 } /* mpz_nonzero() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	743
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	744 static object *
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	745 py_mpz_invert(v)
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	746 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	747 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	748 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 /* 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	752 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	753 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	754
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	755 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	756 return (object *)z;
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	757 } /* py_mpz_invert() */
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	758
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	759 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	760 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	761 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	762 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	763 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	764 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	765 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	766
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	767
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	768 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	769 /* a << 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	770 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	771 return (object *)a;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	774 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	775 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	776 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	777 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	778
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	779 #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	780 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	781 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	782 #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	783 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	784 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	785 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	786 return NULL;
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 #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	789
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	790 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	791 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	792
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	793 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	794 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	795 } /* mpz_lshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	796
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	797 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	798 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	799 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	800 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	801 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	802 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	803 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	804
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 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	807 /* a >> 0 == a */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	808 INCREF(a);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	809 return (object *)a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	810 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	811
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	812 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	813 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	814 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	815 }
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 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	818 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	819
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	820 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	821 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	822
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	823 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	824 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	825 } /* mpz_rshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	826
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	827 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	828 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	829 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	830 mpzobject *b;
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 mpzobject *z;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	835 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	836 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	837
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	838 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	839 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	840 } /* mpz_andfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	841
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	842 /* 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	843 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	844 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	845 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	846 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	847 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	848 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	849 MP_INT tmpmpz;
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 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	852
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	853 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	854 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	855 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	856 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	857
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	858 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	859 } /* mpz_xor() HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	860
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	861 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	862 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	863 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	864 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	867
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	868
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	869 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	870 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	871
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	872 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	873 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	874 } /* mpz_xorfunc() */
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 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	877 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	878 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	879 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	880 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	881 mpzobject *z;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	884 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	885 return NULL;
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 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	888 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	889 } /* mpz_orfunc() */
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 /* MPZ initialisation */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	892
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	893 #include "longintrepr.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	894
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	895 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	896 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	897 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	898 object *args;
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 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	901 object *objp;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	904 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	905 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	906 #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	907
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	908 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	909 return NULL;
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 /* 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	912 /* 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	913
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	914 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	915 long lval;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	916
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	917 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	918 return NULL;
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 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	921 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	922 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	923 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	924 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	925 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	926 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	927 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	928 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	929 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	930 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	931 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	932 else if (is_longobject(objp)) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	933 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	934 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	935 unsigned char isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	936
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	937
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	938 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	939 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	940
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	941 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	942 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	943
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	944 /* how we're gonna handle this? */
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	945 if ((isnegative = ((i = ((longobject *)objp)->ob_size) < 0) ))
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	946 i = -i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	947
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	948 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	949 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	950 (unsigned long)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	951 ((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	952 mpz_mul_2exp(&mplongdigit,&mplongdigit,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	953 (unsigned long int)i * SHIFT);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	954 mpz_ior(&mpzp->mpz, &mpzp->mpz, &mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	955 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	956
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	957 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	958 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	959
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	960 /* 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	961 mpz_clear(&mplongdigit);
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 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	964 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	965 int len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	966 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	967
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	968 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	969 return NULL;
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 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	972 return NULL;
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 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	975 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	976
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	977 /* 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	978 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	979
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	980 cp += len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	981 while (len--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	982 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	983 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	984 (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	985 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	986 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	987
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	988 /* 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	989 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	990 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	991 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	992 INCREF(objp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	993 mpzp = (mpzobject *)objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	994 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	995 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	996 err_setstr(TypeError,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	997 "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	998 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	999 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1000
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1003 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	1004 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	1005 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1006 #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	1007 return (object *)mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1008 } /* MPZ_mpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1009
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1010 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1011 mpz_mpzcoerce(z)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1012 object *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1013 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1014 /* 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	1015 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	1016 INCREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1017 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	1018 }
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 /* 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	1021 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	1022 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	1023
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1024 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	1025 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1026 } /* mpz_mpzcoerce() */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1027
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1028 /* Forward */
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1029 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	1030 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	1031
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1032 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1033 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	1034 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1035 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1036 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1037 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	1038 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	1039 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1040 int tstres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1041
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 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	1044 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1045
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1046 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	1047 \|\| (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	1048 \|\| (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	1049 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1050 XDECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1051 XDECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1052 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1053 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1054 }
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 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	1057 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	1058 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	1059 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1060
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1061 if (tstres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1062 MP_INT absexp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1063 /* negative exp */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1064
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1065 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	1066 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	1067 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	1068
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1069 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	1070
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1071 mpz_clear(&absexp);
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 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1074 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	1075 }
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 DECREF(mpzbase);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1078 DECREF(mpzexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1079 DECREF(mpzmod);
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 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1082 } /* MPZ_powm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1083
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1084
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1085 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1086 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	1087 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1088 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1089 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1090 object op1, op2;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1091 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	1092 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1093
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 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	1096 return NULL;
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 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	1099 \|\| (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	1100 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1101 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1102 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1103 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1104 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1105
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1106 /* 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	1107 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	1108
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1109 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1110 DECREF(mpzop2);
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 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1113 } /* MPZ_gcd() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1114
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1115
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1116 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1117 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	1118 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1119 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1120 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1121 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	1122 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	1123 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	1124
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 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	1127 return NULL;
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 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	1130 \|\| (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	1131 \|\| (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	1132 \|\| (g = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1133 \|\| (s = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1134 \|\| (t = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1135 XDECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1136 XDECREF(mpzop2);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1137 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1138 XDECREF(g);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1139 XDECREF(s);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1140 /XDECREF(t);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1141 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1142 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1143
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1144 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	1145
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1146 DECREF(mpzop1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1147 DECREF(mpzop2);
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 (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	1150 (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	1151 (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	1152
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1153 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1154 } /* MPZ_gcdext() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1155
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1156
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1157 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1158 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	1159 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1160 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1161 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1162 object *op;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1163 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1164 mpzobject *z;
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 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	1168 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1169
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1170 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	1171 \|\| (z = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1172 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1173 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1174 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1175
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1176 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	1177
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1178 DECREF(mpzop);
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 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1181 } /* MPZ_sqrt() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1182
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1183
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1184 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1185 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	1186 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1187 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1188 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1189 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	1190 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1191 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	1192
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1193
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1194 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	1195 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1196
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1197 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	1198 \|\| (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	1199 \|\| (root = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1200 \|\| (rem = newmpzobject()) == NULL) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1201 XDECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1202 XDECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1203 XDECREF(root);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1204 /XDECREF(rem);/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1205 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1206 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1207
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1208 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	1209
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1210 DECREF(mpzop);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1211
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1212 (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	1213 (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	1214
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1215 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1216 } /* MPZ_sqrtrem() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1217
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1218
1425 72bddfad351a * mpzmodule.c: cast some methods to the proper type. Guido van Rossum <guido@python.org> parents: 1400 diff changeset	1219 static void
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1220 #if __STDC__
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1221 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	1222 #else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1223 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	1224 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1225 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	1226 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	1227 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	1228 #endif
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1229 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1230 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	1231
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1232 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	1233 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	1234 mpz_init(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1235 mpz_init(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1236 mpz_init(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1237 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	1238 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	1239
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1240 #ifdef GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1241 while (d1._mp_size != 0) {
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1242 #else
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1243 while (d1.size != 0) {
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1244 #endif
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1245 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	1246 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	1247 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	1248
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1249 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	1250 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	1251 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	1252 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	1253 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1254
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1255 #ifdef GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1256 if (d0._mp_size != 1 \|\| d0._mp_d[0] != 1)
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1257 res->_mp_size = 0; /* trouble: the gcd != 1; set s to zero */
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1258 #else
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1259 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	1260 res->size = 0; /* trouble: the gcd != 1; set s to zero */
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1261 #endif
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1262 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1263 #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	1264 /* 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	1265 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	1266 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	1267 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	1268
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1269 if (res->size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1270 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	1271 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1272 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1273 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	1274
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1275 #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	1276 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	1277 #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	1278 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1279
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1280 mpz_clear(&s0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1281 mpz_clear(&s1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1282 mpz_clear(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1283 mpz_clear(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1284 mpz_clear(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1285 mpz_clear(&d0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1286 mpz_clear(&d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1287 } /* mpz_divm() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1290 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1291 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	1292 object *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1293 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1294 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1295 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	1296 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	1297 mpzobject *z = NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1300 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	1301 return NULL;
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 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	1304 \|\| (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	1305 \|\| (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	1306 \|\| (z = newmpzobject()) == NULL ) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1307 XDECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1308 XDECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1309 XDECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1310 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1311 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1312
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1313 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	1314
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1315 DECREF(mpznum);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1316 DECREF(mpzden);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1317 DECREF(mpzmod);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1318
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1319 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	1320 DECREF(z);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1321 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	1322 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1323 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1324
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1325 return (object *)z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1326 } /* MPZ_divm() */
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 /* 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	1330 #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	1331 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1332 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	1333 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1334 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1335 #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	1336 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1337 mpz_int(self)
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 #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	1340 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1341 long sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1342
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1343
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1344 #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	1345 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1346 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1347 #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	1348
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1349 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	1350 \|\| (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	1351 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	1352 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1353 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1354
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1355 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	1356 sli = -sli;
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 return newintobject(sli);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1359 } /* mpz_int() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1360
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1361 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1362 #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	1363 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	1364 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1365 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1366 #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	1367 mpz_long(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1368 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1369 #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	1370 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1371 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1372 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	1373 longobject *longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1374 int ldcount;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1375 int bitpointer, newbitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1376 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1377
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1378
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1379 #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	1380 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1381 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1382 #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	1383
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1384 /* 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	1385 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	1386 ((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	1387 + SHIFT - 1) /
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1388 SHIFT))) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1389 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1390
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1391 /* 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	1392 mpz_init_set(&mpzscratch, &self->mpz);
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1393 if ((isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)))
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1394 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	1395
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1396 /* 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	1397 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	1398
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1399 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	1400 newbitpointer = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1401 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	1402 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	1403 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1404 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	1405
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1406 /* 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	1407 if (bitpointer < SHIFT) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1408 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	1409 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	1410 (uli << bitpointer) & MASK;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1411 uli >>= SHIFT-bitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1412 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	1413 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	1414 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	1415 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1416 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1417 uli >>= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1418 bitpointer -= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1419 ldcount++;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1420 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1421
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1422 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	1423 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1424 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	1425
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1426 /* 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	1427 /* 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	1428 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	1429 ldcount--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1430 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	1431
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1432
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1433 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1434 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	1435
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1436 return (object *)longobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1437
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1438 } /* mpz_long() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1441 /* 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	1442 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	1443
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1444 #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	1445 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1446 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	1447 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1448 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1449 #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	1450 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1451 mpz_float(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1452 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1453 #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	1454 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1455 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1456 double x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1457 double mulstate;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1458 MP_INT mpzscratch;
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 #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	1462 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1463 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1464 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1465
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1466 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	1467
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1468 /* determine sign, and copy abs(self) to scratch var */
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1469 if ((isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0))) {
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1470 mpz_init(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1471 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	1472 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1473 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1474 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	1475
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1476 /* 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	1477 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	1478
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1479 x = 0.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1480 mulstate = 1.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1481 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1482 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	1483 mulstate *= multiplier;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1484 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	1485 }
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 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	1488 mpz_clear(&mpzscratch);
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 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1491 x = -x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1492
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1493 return newfloatobject(x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1494
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1495 } /* mpz_float() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1496
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1497 #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	1498 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1499 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	1500 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1501 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1502 #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	1503 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1504 mpz_hex(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1505 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1506 #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	1507 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1508 #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	1509 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1510 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1511 #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	1512
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1513 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	1514 } /* mpz_hex() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1515
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1516 #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	1517 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1518 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	1519 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1520 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1521 #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	1522 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1523 mpz_oct(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1524 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1525 #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	1526 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1527 #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	1528 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1529 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1530 #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	1531
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1532 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	1533 } /* mpz_oct() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1534
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1535 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1536 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	1537 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1538 object *args;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1539 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1540 int size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1541 stringobject *strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1542 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1543 MP_INT mp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1544 unsigned long ldigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1545
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1546 if (!getnoarg(args))
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1547 return NULL;
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 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	1550 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	1551 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1554 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	1555 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	1556
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1557 if ((strobjp = (stringobject *)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1558 newsizedstringobject((char *)0,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1559 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	1560 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1561
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1562 /* 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	1563 cp = GETSTRINGVALUE(strobjp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1564
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1565 /* 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	1566 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	1567 while (size--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1568 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	1569 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	1570 *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	1571 *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	1572 *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	1573 *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	1574 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1575
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1576 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	1577 strobjp->ob_size--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1578
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1579 return (object *)strobjp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1580 } /* mpz_binary() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1581
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 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	1584 #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	1585 {"int", mpz_int},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1586 {"long", mpz_long},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1587 {"float", mpz_float},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1588 {"hex", mpz_hex},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1589 {"oct", mpz_oct},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1590 #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	1591 {"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	1592 {NULL, NULL} /* sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1593 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1594
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1595 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1596 mpz_getattr(self, name)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1597 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1598 char *name;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1599 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1600 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	1601 } /* mpz_getattr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1602
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1603
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1604 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1605 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	1606 object **pv;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1607 object **pw;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1608 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1609 object *z;
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1612 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	1613 #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	1614
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1615 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	1616
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1617 /* 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	1618 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	1619 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	1620 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	1621
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1622 INCREF(*pv);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1623 *pw = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1624 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1625 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1626 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	1627 return -1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1628
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1629 INCREF(*pw);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1630 *pv = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1631 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1632 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	1633
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1634 } /* mpz_coerce() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1635
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1636
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1637 static object *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1638 mpz_repr(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1639 object *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1640 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1641 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	1642 } /* mpz_repr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1643
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1644
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1645
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1646 #define UF (unaryfunc)
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1647 #define BF (binaryfunc)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1648 #define TF (ternaryfunc)
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1649 #define IF (inquiry)
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1650 #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	1651
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1652 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	1653 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	1654 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	1655 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	1656 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	1657 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	1658 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	1659 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	1660 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	1661 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	1662 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	1663 IF mpz_nonzero, /tp_nonzero/
4052 ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2 Guido van Rossum <guido@python.org> parents: 2309 diff changeset	1664 UF py_mpz_invert, /nb_invert/
1132 6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1665 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	1666 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	1667 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	1668 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	1669 BF mpz_orfunc, /nb_or/
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1670 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	1671 #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	1672 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	1673 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	1674 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	1675 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	1676 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	1677 #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	1678 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1679
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1680 static typeobject MPZtype = {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1681 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	1682 0, /ob_size/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1683 "mpz", /tp_name/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1684 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	1685 0, /tp_itemsize/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1686 /* methods */
1746 1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1687 (destructor)mpz_dealloc, /tp_dealloc/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1688 0, /tp_print/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1689 (getattrfunc)mpz_getattr, /tp_getattr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1690 0, /tp_setattr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1691 (cmpfunc)mpz_compare, /tp_compare/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1692 (reprfunc)mpz_repr, /tp_repr/
1940892d2fe3 Merge alpha100 branch back to main trunk Guido van Rossum <guido@python.org> parents: 1425 diff changeset	1693 &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	1694 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1695
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1696 /* 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	1697
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1698 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	1699 #if 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1700 {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	1701 #else /* 0 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1702 /* 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	1703 {(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	1704 #endif /* 0 else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1705 {"powm", MPZ_powm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1706 {"gcd", MPZ_gcd},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1707 {"gcdext", MPZ_gcdext},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1708 {"sqrt", MPZ_sqrt},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1709 {"sqrtrem", MPZ_sqrtrem},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1710 {"divm", MPZ_divm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1711 {NULL, NULL} /* Sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1712 };
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1715 /* #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	1716
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1717 #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	1718 #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	1719 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	1720 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	1721 int *location;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1722 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1723 /* 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	1724 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	1725 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	1726 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	1727 } /* 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	1728 #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	1729 #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	1730 #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	1731 ; \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1732 else \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1733 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	1734 #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	1735 #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	1736 #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	1737 #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	1738 #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	1739
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1740 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	1741 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	1742 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1743 void *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1744
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1745 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1746 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	1747 alloc_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1748 #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	1749
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1750 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	1751 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	1752
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1753 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1754 fprintf(stderr, "mp_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	1755 #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	1756
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1757 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	1758
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1759 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1760 } /* mp_allocate() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1761
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1762
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1763 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	1764 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1765 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	1766 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	1767 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1768 void *res;
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_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	1772 ptr, old_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, old_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1776
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1777 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	1778 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	1779
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1780 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1781 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	1782 res, new_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1783 #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	1784
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1785 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	1786
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1787 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1788 } /* mp_reallocate() */
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1791 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	1792 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1793 size_t size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1794 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1795
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1796 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1797 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	1798 ptr, size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1799 #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	1800
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1801 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	1802 free(ptr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1803 } /* mp_free() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1804
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1807 /* Initialize this module. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1808
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1809 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1810 initmpz()
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1811 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1812 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1813 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	1814 #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	1815
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1816 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	1817 (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	1818
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1819 /* 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	1820 if ((mpz_value_zero = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1821 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	1822 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	1823
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1824 if ((mpz_value_one = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1825 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	1826 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	1827
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1828 if ((mpz_value_mone = newmpzobject()) == NULL)
2055 cf31eab6ab5a Another bulky set of minor changes. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	1829 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	1830 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	1831
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1832 } /* initmpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1833 #ifdef MAKEDUMMYINT
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's Guido van Rossum <guido@python.org> parents: diff changeset	1834 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	1835 #endif /* def MAKEDUMMYINT */

Mercurial > cpython-lru_cache-weakref

annotate Modules/mpzmodule.c @ 4566:6403c94de50d legacy-trunk