Mercurial > cpython-lru_cache-weakref

annotate Modules/mpzmodule.c @ 6719:faebc1940432 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Understand -Xlinker option.
author Guido van Rossum <guido@python.org>
date Tue, 02 Dec 1997 20:38:11 +0000
parents f9f0262c4c57
children 672a657abba8
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
43 #include "Python.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
6085
f9f0262c4c57 Use a trick to make the test for GMP v2 to work when GMP v1 defines
Guido van Rossum <guido@python.org>
parents: 5197
diff changeset
97 #if __GNU_MP__ + 0 == 2
4052
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 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
104 PyObject_HEAD
1132
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
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
108 staticforward PyTypeObject 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 */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
125 mpzp = PyObject_NEW(mpzobject, &MPZtype);
1132
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
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
137 static PyObject *
1132
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)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
139 PyObject *objp;
1132
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;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
144 PyStringObject *strobjp;
1132
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)) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
155 PyErr_BadInternalCall();
1132
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 */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
224 if ((strobjp =
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
225 (PyStringObject *)PyString_FromStringAndSize((char *)0, i))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
226 == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
227 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
228
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
229 /* get the beginning of the string memory and start copying things */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
230 cp = PyString_AS_STRING(strobjp);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
231 if (withname) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
232 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
233 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
234 *cp++ = '('; /*')'*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
235 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
236
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
237 /* 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
238 *tcp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
239 strcpy(cp, prefix);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
240 cp += tcp - prefix;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
241
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
242 /* since' we have the sign already, let the lib think it's a positive
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
243 number */
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
244 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
245 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
246 (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
247 if (cmpres < 0)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
248 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
249 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
250 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
251 base, cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
252 #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
253 cp += strlen(cp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
254
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
255 if (taglong)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
256 *cp++ = 'L';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
257 if (withname)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
258 *cp++ = /*'('*/ ')';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
259
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
260 *cp = '\0';
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
261
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
262 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
263 fprintf(stderr,
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
264 "mpz_format: cp (str end) 0x%x, begin 0x%x, diff %d, i %d\n",
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
265 cp, PyString_AS_STRING(strobjp),
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
266 cp - PyString_AS_STRING(strobjp), i);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
267 #endif /* def MPZ_DEBUG */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
268 assert(cp - PyString_AS_STRING(strobjp) <= i);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
269
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
270 if (cp - PyString_AS_STRING(strobjp) != i) {
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
271 strobjp->ob_size -= i - (cp - PyString_AS_STRING(strobjp));
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
272 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
273
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
274 return (PyObject *)strobjp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
275 } /* mpz_format() */
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 /* MPZ methods */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
278
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
279 static void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
280 mpz_dealloc(mpzp)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
281 mpzobject *mpzp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
282 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
283 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
284 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
285 #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
286 mpz_clear(&mpzp->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
287 PyMem_DEL(mpzp);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
288 } /* mpz_dealloc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
289
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
290
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
291 /* 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
292 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
293
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
294 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
295 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
296 mpzobject *a, *b;
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 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
299
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
300
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
301 /* 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
302 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
303 : 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
304 } /* mpz_compare() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
305
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
306 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
307 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
308 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
309 mpzobject *b;
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 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
312
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
313
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
314 #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
315 if (mpz_cmp_ui(&a->mpz, (unsigned long int)0) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
316 Py_INCREF(b);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
317 return (PyObject *)b;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
318 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
319
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
320 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
321 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
322 return (PyObject *)a;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
323 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
324 #endif /* 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
325
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
326 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
327 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
328
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
329 mpz_add(&z->mpz, &a->mpz, &b->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
330 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
331 } /* mpz_addition() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
332
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
333 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
334 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
335 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
336 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
337 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
338 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
339
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
340
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
341 #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
342 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
343 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
344 return (PyObject *)a;
1132
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 #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
347
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
348 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
349 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
350
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
351 mpz_sub(&z->mpz, &a->mpz, &b->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
352 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
353 } /* mpz_substract() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
354
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
355 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
356 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
357 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
358 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
359 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
360 #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
361 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
362 #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
363 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
364
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
365
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
366 #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
367 if ((cmpres = mpz_cmp_ui(&a->mpz, (unsigned long int)0)) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
368 Py_INCREF(mpz_value_zero);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
369 return (PyObject *)mpz_value_zero;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
370 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
371 if (cmpres > 0 && mpz_cmp_ui(&a->mpz, (unsigned long int)1) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
372 Py_INCREF(b);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
373 return (PyObject *)b;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
374 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
375
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
376 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long_int)0)) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
377 Py_INCREF(mpz_value_zero);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
378 return (PyObject *)mpz_value_zero;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
379 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
380 if (cmpres > 0 && mpz_cmp_ui(&b->mpz, (unsigned long int)1) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
381 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
382 return (PyObject *)a;
1132
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 #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
385
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
386 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
387 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
388
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
389 mpz_mul( &z->mpz, &a->mpz, &b->mpz );
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
390 return (PyObject *)z;
1132
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 } /* mpz_multiply() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
393
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
394 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
395 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
396 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
397 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
398 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
399 #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
400 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
401 #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
402 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
403
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
404
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
405 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
406 #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
407 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
408 #endif /* def MPZ_SPARE_MALLOC */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
409 mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
410 PyErr_SetString(PyExc_ZeroDivisionError, "mpz./ by zero");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
411 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
412 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
413 #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
414 if (cmpres > 0 && mpz_cmp_ui(&b->mpz(unsigned long int)1) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
415 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
416 return (PyObject *)a;
1132
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 #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
419
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
420 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
421 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
422
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
423 #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
424 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
425 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
426 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
427 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
428 #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
429 #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
430 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
431 != (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
432 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
433 ** 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
434 ** 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
435 ** 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
436 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
437 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
438
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
439
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
440 mpz_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
441 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
442
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
443 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
444 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
445
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
446 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
447 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
448 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
449 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
450 /* 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
451 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
452
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
453 #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
454 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
455 #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
456 #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
457 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
458 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
459 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
460 #endif /* def MPZ_TEST_DIV */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
461 return (PyObject *)z;
1132
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 } /* mpz_divide() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
464
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
465 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
466 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
467 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
468 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
469 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
470 #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
471 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
472 #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
473 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
474
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
475
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
476 if ((
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
477 #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
478 cmpres =
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
479 #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
480 mpz_cmp_ui(&b->mpz, (unsigned long int)0)) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
481 PyErr_SetString(PyExc_ZeroDivisionError, "mpz.% by zero");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
482 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
483 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
484 #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
485 if (cmpres > 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
486 if ((cmpres = mpz_cmp_ui(&b->mpz, (unsigned long int)2)) == 0)
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
487 {
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
488 Py_INCREF(mpz_value_one);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
489 return (PyObject *)mpz_value_one;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
490 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
491 if (cmpres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
492 /* b must be 1 now */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
493 Py_INCREF(mpz_value_zero);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
494 return (PyObject *)mpz_value_zero;
1132
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 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
497 #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
498
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
499 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
500 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
501
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
502 #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
503 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
504 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
505 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
506 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
507 #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
508 #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
509
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
510 /* 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
511 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
512 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
513
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
514 /* 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
515 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
516 != (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
517 && 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
518 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
519 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
520 ** 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
521 ** 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
522 ** 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
523 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
524 #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
525 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
526 #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
527 #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
528 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
529 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
530 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
531 #endif /* def MPZ_TEST_DIV */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
532 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
533
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
534 } /* mpz_remainder() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
535
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
536 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
537 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
538 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
539 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
540 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
541 PyObject *z = NULL;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
542 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
543
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
544
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
545 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
546 PyErr_SetString(PyExc_ZeroDivisionError, "mpz.divmod by zero");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
547 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
548 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
549
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
550 if ((z = PyTuple_New(2)) == NULL
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
551 || (x = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
552 || (y = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
553 Py_XDECREF(z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
554 Py_XDECREF(x);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
555 Py_XDECREF(y);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
556 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
557 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
558
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
559 #ifdef MPZ_TEST_DIV
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
560 fputs("mpz_divmod: dm result", stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
561 mpz_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
562 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
563 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
564 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
565 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
566 #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
567 #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
568 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
569 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
570 != (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
571 && 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
572 /*
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
573 ** 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
574 ** 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
575 */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
576 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
577 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
578 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
579 #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
580 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
581 #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
582 #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
583 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
584 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
585 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
586 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
587 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
588 #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
589
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
590 (void)PyTuple_SetItem(z, 0, (PyObject *)x);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
591 (void)PyTuple_SetItem(z, 1, (PyObject *)y);
1132
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 return z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
594 } /* 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
595
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
596 static PyObject *
2055
cf31eab6ab5a Another bulky set of minor changes.
Guido van Rossum <guido@python.org>
parents: 1746
diff changeset
597 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
598 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
599 mpzobject *b;
2055
cf31eab6ab5a Another bulky set of minor changes.
Guido van Rossum <guido@python.org>
parents: 1746
diff changeset
600 mpzobject *m;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
601 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
602 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
603 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
604
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
605 if ((PyObject *)m != Py_None) {
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
606 mpzobject *z2;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
607 Py_INCREF(Py_None);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
608 z=(mpzobject *)mpz_power(a, b, (mpzobject *)Py_None);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
609 Py_DECREF(Py_None);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
610 if (z==NULL) return((PyObject *)z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
611 z2=(mpzobject *)mpz_remainder(z, m);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
612 Py_DECREF(z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
613 return((PyObject *)z2);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
614 }
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
615
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
616 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
617 /* 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
618
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
619 Py_INCREF(mpz_value_one);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
620 return (PyObject *)mpz_value_one;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
621 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
622
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
623 if (cmpres < 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
624 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
625 "mpz.pow to negative exponent");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
626 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
627 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
628
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
629 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
630 /* 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
631
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
632 Py_INCREF(mpz_value_zero);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
633 return (PyObject *)mpz_value_zero;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
634 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
635 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
636 && 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
637 /* 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
638
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
639 Py_INCREF(mpz_value_one);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
640 return (PyObject *)mpz_value_one;
1132
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 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
643 && 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
644
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
645 MP_INT tmpmpz;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
646 /* 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
647 /* 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
648 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
649 for *un*obvious reasons */
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 /* 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
652 mpz_init(&tmpmpz);
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 /* 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
655 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
656
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
657 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
658 mpz_clear(&tmpmpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
659 Py_INCREF(mpz_value_one);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
660 return (PyObject *)mpz_value_one;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
661 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
662 mpz_clear(&tmpmpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
663 Py_INCREF(mpz_value_mone);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
664 return (PyObject *)mpz_value_mone;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
665 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
666
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
667 #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
668 /* 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
669 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
670 if (mpz_size(&b->mpz) > 1)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
671 return (PyObject *)PyErr_NoMemory();
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
672 #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
673 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
674 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
675 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
676 "mpz.pow outrageous exponent");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
677 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
678 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
679 #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
680
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
681 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
682 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
683
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
684 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
685
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
686 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
687 } /* mpz_power() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
688
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
689
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
690 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
691 mpz_negative(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
692 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
693 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
694 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
695
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
696
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
697 #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
698 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
699 /* -0 == 0 */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
700 Py_INCREF(v);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
701 return (PyObject *)v;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
702 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
703 #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
704
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
705 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
706 return NULL;
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 mpz_neg(&z->mpz, &v->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
709 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
710 } /* mpz_negative() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
711
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
712
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
713 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
714 mpz_positive(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
715 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
716 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
717 Py_INCREF(v);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
718 return (PyObject *)v;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
719 } /* mpz_positive() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
720
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
721
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
722 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
723 mpz_absolute(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
724 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
725 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
726 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
727
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
728
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
729 if (mpz_cmp_ui(&v->mpz, (unsigned long int)0) >= 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
730 Py_INCREF(v);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
731 return (PyObject *)v;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
732 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
733
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
734 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
735 return NULL;
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 mpz_neg(&z->mpz, &v->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
738 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
739 } /* mpz_absolute() */
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 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
742 mpz_nonzero(v)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
743 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
744 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
745 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
746 } /* mpz_nonzero() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
747
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
748 static PyObject *
4052
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
749 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
750 mpzobject *v;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
751 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
752 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
753
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 /* 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
756 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
757 return NULL;
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 mpz_com(&z->mpz, &v->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
760 return (PyObject *)z;
4052
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
761 } /* 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
762
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
763 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
764 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
765 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
766 mpzobject *b;
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 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
769 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
770
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
771
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
772 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
773 /* a << 0 == a */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
774 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
775 return (PyObject *)a;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
776 }
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 if (cmpres < 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
779 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
780 "mpz.<< negative shift count");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
781 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
782 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
783
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
784 #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
785 if (mpz_size(&b->mpz) > 1)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
786 return (PyObject *)PyErr_NoMemory();
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
787 #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
788 /* wet finger method */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
789 if (mpz_cmp_ui(&b->mpz, (unsigned long int)0x10000) >= 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
790 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
791 "mpz.<< outrageous shift count");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
792 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
793 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
794 #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
795
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
796 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
797 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
798
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
799 mpz_mul_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
800 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
801 } /* mpz_lshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
802
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
803 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
804 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
805 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
806 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
807 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
808 int cmpres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
809 mpzobject *z;
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 = 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
813 /* a >> 0 == a */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
814 Py_INCREF(a);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
815 return (PyObject *)a;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
816 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
817
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
818 if (cmpres < 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
819 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
820 "mpz.>> negative shift count");
1132
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
824 if (mpz_size(&b->mpz) > 1)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
825 return (PyObject *)PyErr_NoMemory();
1132
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 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
828 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
829
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
830 mpz_div_2exp(&z->mpz, &a->mpz, mpz_get_ui(&b->mpz));
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
831 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
832 } /* mpz_rshift() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
833
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
834 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
835 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
836 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
837 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
838 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
839 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
840
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
841
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
842 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
843 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
844
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
845 mpz_and(&z->mpz, &a->mpz, &b->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
846 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
847 } /* mpz_andfunc() */
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 /* 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
850 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
851 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
852 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
853 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
854 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
855 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
856 MP_INT 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_init(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
859
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
860 mpz_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
861 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
862 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
863 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
864
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
865 mpz_clear(&tmpmpz);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
866 } /* mpz_xor() HACK */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
867
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
868 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
869 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
870 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
871 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
872 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
873 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
874
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 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
877 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
878
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
879 mpz_xor(&z->mpz, &a->mpz, &b->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
880 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
881 } /* mpz_xorfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
882
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
883 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
884 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
885 mpzobject *a;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
886 mpzobject *b;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
887 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
888 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
889
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
890
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
891 if ((z = newmpzobject()) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
892 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
893
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
894 mpz_ior(&z->mpz, &a->mpz, &b->mpz);
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
895 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
896 } /* mpz_orfunc() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
897
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
898 /* MPZ initialisation */
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 #include "longintrepr.h"
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
901
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
902 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
903 MPZ_mpz(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
904 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
905 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
906 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
907 mpzobject *mpzp;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
908 PyObject *objp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
909
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
910
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
911 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
912 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
913 #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
914
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
915 if (!PyArg_Parse(args, "O", &objp))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
916 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
917
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
918 /* at least we know it's some object */
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
919 /* note DON't Py_DECREF args NEITHER objp */
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
920
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
921 if (PyInt_Check(objp)) {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
922 long lval;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
923
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
924 if (!PyArg_Parse(objp, "l", &lval))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
925 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
926
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
927 if (lval == (long)0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
928 Py_INCREF(mpz_value_zero);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
929 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
930 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
931 else if (lval == (long)1) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
932 Py_INCREF(mpz_value_one);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
933 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
934 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
935 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
936 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
937 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
938 }
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
939 else if (PyLong_Check(objp)) {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
940 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
941 int i;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
942 unsigned char isnegative;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
945 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
946 return NULL;
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 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
949 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
950
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
951 /* how we're gonna handle this? */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
952 if ((isnegative =
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
953 ((i = ((PyLongObject *)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
954 i = -i;
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 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
957 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
958 (unsigned long)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
959 ((PyLongObject *)objp)->ob_digit[i]);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
960 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
961 (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
962 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
963 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
964
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
965 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
966 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
967
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
968 /* 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
969 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
970 }
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
971 else if (PyString_Check(objp)) {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
972 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
973 int len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
974 MP_INT mplongdigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
975
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
976 if (!PyArg_Parse(objp, "s#", &cp, &len))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
977 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
978
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
979 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
980 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
981
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
982 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
983 mpz_init(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
984
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
985 /* 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
986 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
987
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
988 cp += len;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
989 while (len--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
990 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
991 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
992 (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
993 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
994 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
995
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
996 /* 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
997 mpz_clear(&mplongdigit);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
998 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
999 else if (is_mpzobject(objp)) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1000 Py_INCREF(objp);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1001 mpzp = (mpzobject *)objp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1002 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1003 else {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1004 PyErr_SetString(PyExc_TypeError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1005 "mpz.mpz() expects integer, long, string or mpz object argument");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1006 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1007 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1008
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1009
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1010 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1011 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
1012 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
1013 putc('\n', stderr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1014 #endif /* def MPZ_DEBUG */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1015 return (PyObject *)mpzp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1016 } /* MPZ_mpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1017
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1018 static mpzobject *
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1019 mpz_mpzcoerce(z)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1020 PyObject *z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1021 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1022 /* 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
1023 if (is_mpzobject(z)) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1024 Py_INCREF(z);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1025 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
1026 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1027
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1028 /* what types do we accept?: intobjects and longobjects */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1029 if (PyInt_Check(z) || PyLong_Check(z))
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1030 return (mpzobject *)MPZ_mpz((PyObject *)NULL, z);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1031
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1032 PyErr_SetString(PyExc_TypeError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1033 "number coercion (to mpzobject) failed");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1034 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1035 } /* mpz_mpzcoerce() */
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1036
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1037 /* Forward */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1038 static void mpz_divm Py_PROTO((MP_INT *res, const MP_INT *num,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1039 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
1040
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1041 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1042 MPZ_powm(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1043 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1044 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1045 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1046 PyObject *base, *exp, *mod;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1047 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
1048 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1049 int tstres;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1050
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1051
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1052 if (!PyArg_Parse(args, "(OOO)", &base, &exp, &mod))
1132
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 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
1056 || (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
1057 || (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
1058 || (z = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1059 Py_XDECREF(mpzbase);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1060 Py_XDECREF(mpzexp);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1061 Py_XDECREF(mpzmod);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1062 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1063 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1064
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1065 if ((tstres=mpz_cmp_ui(&mpzexp->mpz, (unsigned long int)0)) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1066 Py_INCREF(mpz_value_one);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1067 return (PyObject *)mpz_value_one;
1132
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1070 if (tstres < 0) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1071 MP_INT absexp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1072 /* negative exp */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1073
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1074 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
1075 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
1076 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
1077
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1078 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
1079
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1080 mpz_clear(&absexp);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1081 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1082 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1083 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
1084 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1085
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1086 Py_DECREF(mpzbase);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1087 Py_DECREF(mpzexp);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1088 Py_DECREF(mpzmod);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1089
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1090 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1091 } /* MPZ_powm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1092
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1093
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1094 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1095 MPZ_gcd(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1096 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1097 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1098 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1099 PyObject *op1, *op2;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1100 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
1101 mpzobject *z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1102
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1103
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1104 if (!PyArg_Parse(args, "(OO)", &op1, &op2))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1105 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1106
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1107 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
1108 || (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
1109 || (z = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1110 Py_XDECREF(mpzop1);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1111 Py_XDECREF(mpzop2);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1112 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1113 }
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 /* 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
1116 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
1117
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1118 Py_DECREF(mpzop1);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1119 Py_DECREF(mpzop2);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1120
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1121 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1122 } /* MPZ_gcd() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1123
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1124
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1125 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1126 MPZ_gcdext(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1127 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1128 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1129 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1130 PyObject *op1, *op2, *z = NULL;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1131 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
1132 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
1133
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1134
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1135 if (!PyArg_Parse(args, "(OO)", &op1, &op2))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1136 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1137
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1138 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
1139 || (mpzop2 = mpz_mpzcoerce(op2)) == NULL
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1140 || (z = PyTuple_New(3)) == NULL
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1141 || (g = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1142 || (s = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1143 || (t = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1144 Py_XDECREF(mpzop1);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1145 Py_XDECREF(mpzop2);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1146 Py_XDECREF(z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1147 Py_XDECREF(g);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1148 Py_XDECREF(s);
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
1149 /*Py_XDECREF(t);*/
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1150 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1151 }
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 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
1154
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1155 Py_DECREF(mpzop1);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1156 Py_DECREF(mpzop2);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1157
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1158 (void)PyTuple_SetItem(z, 0, (PyObject *)g);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1159 (void)PyTuple_SetItem(z, 1, (PyObject *)s);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1160 (void)PyTuple_SetItem(z, 2, (PyObject *)t);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1161
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1162 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1163 } /* MPZ_gcdext() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1164
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1165
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1166 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1167 MPZ_sqrt(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1168 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1169 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1170 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1171 PyObject *op;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1172 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1173 mpzobject *z;
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
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1176 if (!PyArg_Parse(args, "O", &op))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1177 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1178
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1179 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
1180 || (z = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1181 Py_XDECREF(mpzop);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1182 return NULL;
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
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1185 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
1186
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1187 Py_DECREF(mpzop);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1188
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1189 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1190 } /* MPZ_sqrt() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1191
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1192
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1193 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1194 MPZ_sqrtrem(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1195 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1196 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1197 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1198 PyObject *op, *z = NULL;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1199 mpzobject *mpzop = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1200 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
1201
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1202
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1203 if (!PyArg_Parse(args, "O", &op))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1204 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1205
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1206 if ((mpzop = mpz_mpzcoerce(op)) == NULL
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1207 || (z = PyTuple_New(2)) == NULL
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1208 || (root = newmpzobject()) == NULL
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1209 || (rem = newmpzobject()) == NULL) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1210 Py_XDECREF(mpzop);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1211 Py_XDECREF(z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1212 Py_XDECREF(root);
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
1213 /*Py_XDECREF(rem);*/
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1214 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1215 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1216
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1217 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
1218
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1219 Py_DECREF(mpzop);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1220
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1221 (void)PyTuple_SetItem(z, 0, (PyObject *)root);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1222 (void)PyTuple_SetItem(z, 1, (PyObject *)rem);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1223
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1224 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1225 } /* MPZ_sqrtrem() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1226
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1227
1425
72bddfad351a * mpzmodule.c: cast some methods to the proper type.
Guido van Rossum <guido@python.org>
parents: 1400
diff changeset
1228 static void
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1229 #if __STDC__
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1230 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
1231 #else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1232 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
1233 MP_INT *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1234 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
1235 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
1236 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
1237 #endif
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1238 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1239 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
1240
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1241 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
1242 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
1243 mpz_init(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1244 mpz_init(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1245 mpz_init(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1246 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
1247 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
1248
4052
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
1249 #ifdef GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
1250 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
1251 #else
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1252 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
1253 #endif
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1254 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
1255 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
1256 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
1257
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1258 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
1259 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
1260 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
1261 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
1262 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1263
4052
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
1264 #ifdef GMP2
ef6c89fe21ed Changes by Rob Hooft for GMP 2.0.2
Guido van Rossum <guido@python.org>
parents: 2309
diff changeset
1265 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
1266 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
1267 #else
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1268 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
1269 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
1270 #endif
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1271 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1272 #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
1273 /* 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
1274 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
1275 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
1276 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
1277
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1278 if (res->size)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1279 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
1280 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1281 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1282 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
1283
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1284 #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
1285 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
1286 #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
1287 }
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 mpz_clear(&s0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1290 mpz_clear(&s1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1291 mpz_clear(&q);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1292 mpz_clear(&r);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1293 mpz_clear(&x);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1294 mpz_clear(&d0);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1295 mpz_clear(&d1);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1296 } /* mpz_divm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1297
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1298
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1299 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1300 MPZ_divm(self, args)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1301 PyObject *self;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1302 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1303 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1304 PyObject *num, *den, *mod;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1305 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
1306 mpzobject *z = NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1307
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1308
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1309 if (!PyArg_Parse(args, "(OOO)", &num, &den, &mod))
1132
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 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
1313 || (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
1314 || (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
1315 || (z = newmpzobject()) == NULL ) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1316 Py_XDECREF(mpznum);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1317 Py_XDECREF(mpzden);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1318 Py_XDECREF(mpzmod);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1319 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1320 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1321
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1322 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
1323
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1324 Py_DECREF(mpznum);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1325 Py_DECREF(mpzden);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1326 Py_DECREF(mpzmod);
1132
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 if (mpz_cmp_ui(&z->mpz, (unsigned long int)0) == 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1329 Py_DECREF(z);
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1330 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1331 "gcd(den, mod) != 1 or num == 0");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1332 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1333 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1334
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1335 return (PyObject *)z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1336 } /* MPZ_divm() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1337
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1338
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1339 /* 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
1340 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1341 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1342 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
1343 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1344 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1345 #else /* def MPZ_CONVERSIONS_AS_METHODS */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1346 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1347 mpz_int(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1348 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1349 #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
1350 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1351 long sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1352
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1353
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1354 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1355 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1356 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1357 #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
1358
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1359 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
1360 || (sli = (long)mpz_get_ui(&self->mpz)) < (long)0 ) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1361 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1362 "mpz.int() arg too long to convert");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1363 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1364 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1365
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1366 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
1367 sli = -sli;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1368
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1369 return PyInt_FromLong(sli);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1370 } /* mpz_int() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1371
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1372 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1373 #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
1374 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
1375 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1376 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1377 #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
1378 mpz_long(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1379 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1380 #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
1381 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1382 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1383 unsigned long int uli;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1384 PyLongObject *longobjp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1385 int ldcount;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1386 int bitpointer, newbitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1387 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1388
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1389
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1390 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1391 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1392 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1393 #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
1394
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1395 /* determine length of python-long to be allocated */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1396 if ((longobjp = _PyLong_New(i = (int)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1397 ((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
1398 + SHIFT - 1) /
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1399 SHIFT))) == NULL)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1400 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1401
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1402 /* 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
1403 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
1404 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
1405 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
1406
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1407 /* let those bits come, let those bits go,
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
1408 e.g. dismantle mpzscratch, build PyLongObject */
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1409
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1410 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
1411 newbitpointer = 0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1412 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
1413 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
1414 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1415 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
1416
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1417 /* 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
1418 if (bitpointer < SHIFT) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1419 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
1420 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
1421 (uli << bitpointer) & MASK;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1422 uli >>= SHIFT-bitpointer;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1423 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
1424 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
1425 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
1426 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1427 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1428 uli >>= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1429 bitpointer -= SHIFT;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1430 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 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
1434 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1435 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
1436
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1437 /* 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
1438 /* 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
1439 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
1440 ldcount--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1441 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
1442
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 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1445 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
1446
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1447 return (PyObject *)longobjp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1448
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1449 } /* mpz_long() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1450
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1451
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1452 /* 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
1453 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
1454
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1455 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1456 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1457 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
1458 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1459 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1460 #else /* def MPZ_CONVERSIONS_AS_METHODS */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1461 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1462 mpz_float(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1463 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1464 #endif /* def MPZ_CONVERSIONS_AS_METHODS else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1465 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1466 int i, isnegative;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1467 double x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1468 double mulstate;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1469 MP_INT mpzscratch;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1470
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1471
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1472 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1473 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1474 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1475 #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
1476
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1477 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
1478
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1479 /* determine sign, and copy abs(self) to scratch var */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1480 if ((isnegative = (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0)))
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1481 {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1482 mpz_init(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1483 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
1484 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1485 else
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1486 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
1487
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1488 /* let those bits come, let those bits go,
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
1489 e.g. dismantle mpzscratch, build PyFloatObject */
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1490
5120
a48f3678f9e1 Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents: 4645
diff changeset
1491 /* Can this overflow? Dunno, protect against that possibility. */
a48f3678f9e1 Changes for Lee Busby's SIGFPE patch set.
Guido van Rossum <guido@python.org>
parents: 4645
diff changeset
1492 PyFPE_START_PROTECT("mpz_float", return 0)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1493 x = 0.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1494 mulstate = 1.0;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1495 while (i--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1496 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
1497 mulstate *= multiplier;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1498 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
1499 }
5197
74c12704a0bd New form of PyFPE_END_PROTECT macro.
Guido van Rossum <guido@python.org>
parents: 5120
diff changeset
1500 PyFPE_END_PROTECT(mulstate)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1501
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1502 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
1503 mpz_clear(&mpzscratch);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1504
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1505 if (isnegative)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1506 x = -x;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1507
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1508 return PyFloat_FromDouble(x);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1509
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1510 } /* mpz_float() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1511
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1512 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1513 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1514 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
1515 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1516 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1517 #else /* def MPZ_CONVERSIONS_AS_METHODS */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1518 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1519 mpz_hex(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1520 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1521 #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
1522 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1523 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1524 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1525 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1526 #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
1527
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1528 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
1529 } /* mpz_hex() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1530
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1531 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1532 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1533 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
1534 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1535 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1536 #else /* def MPZ_CONVERSIONS_AS_METHODS */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1537 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1538 mpz_oct(self)
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1539 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1540 #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
1541 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1542 #ifdef MPZ_CONVERSIONS_AS_METHODS
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1543 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1544 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1545 #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
1546
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1547 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
1548 } /* mpz_oct() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1549
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1550 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1551 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
1552 mpzobject *self;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1553 PyObject *args;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1554 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1555 int size;
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1556 PyStringObject *strobjp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1557 char *cp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1558 MP_INT mp;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1559 unsigned long ldigit;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1560
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1561 if (!PyArg_NoArgs(args))
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1562 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1563
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1564 if (mpz_cmp_ui(&self->mpz, (unsigned long int)0) < 0) {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1565 PyErr_SetString(PyExc_ValueError,
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1566 "mpz.binary() arg must be >= 0");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1567 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1568 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1569
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1570 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
1571 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
1572
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1573 if ((strobjp = (PyStringObject *)
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1574 PyString_FromStringAndSize(
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1575 (char *)0, size * sizeof (unsigned long int))) == NULL)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1576 return NULL;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1577
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1578 /* get the beginning of the string memory and start copying things */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1579 cp = PyString_AS_STRING(strobjp);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1580
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1581 /* 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
1582 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
1583 while (size--) {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1584 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
1585 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
1586 *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
1587 *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
1588 *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
1589 *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
1590 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1591
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1592 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
1593 strobjp->ob_size--;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1594
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1595 return (PyObject *)strobjp;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1596 } /* mpz_binary() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1597
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1598
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1599 static PyMethodDef mpz_methods[] = {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1600 #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
1601 {"int", mpz_int},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1602 {"long", mpz_long},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1603 {"float", mpz_float},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1604 {"hex", mpz_hex},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1605 {"oct", mpz_oct},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1606 #endif /* def MPZ_CONVERSIONS_AS_METHODS */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1607 {"binary", (PyCFunction)mpz_binary},
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1608 {NULL, NULL} /* sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1609 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1610
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1611 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1612 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
1613 mpzobject *self;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1614 char *name;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1615 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1616 return Py_FindMethod(mpz_methods, (PyObject *)self, name);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1617 } /* mpz_getattr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1618
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1619
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1620 static int
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1621 mpz_coerce(pv, pw)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1622 PyObject **pv;
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1623 PyObject **pw;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1624 {
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1625 PyObject *z;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1626
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1627 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1628 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
1629 #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
1630
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1631 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
1632
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1633 /* always convert other arg to mpz value, except for floats */
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1634 if (!PyFloat_Check(*pw)) {
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1635 if ((z = (PyObject *)mpz_mpzcoerce(*pw)) == NULL)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1636 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
1637
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1638 Py_INCREF(*pv);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1639 *pw = z;
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 else {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1642 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
1643 return -1;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1644
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1645 Py_INCREF(*pw);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1646 *pv = z;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1647 }
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1648 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
1649
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1650 } /* mpz_coerce() */
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
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1653 static PyObject *
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1654 mpz_repr(v)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1655 PyObject *v;
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1656 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1657 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
1658 } /* mpz_repr() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1659
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1660
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1661
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1662 #define UF (unaryfunc)
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1663 #define BF (binaryfunc)
2055
cf31eab6ab5a Another bulky set of minor changes.
Guido van Rossum <guido@python.org>
parents: 1746
diff changeset
1664 #define TF (ternaryfunc)
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1665 #define IF (inquiry)
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1666 #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
1667
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1668 static PyNumberMethods mpz_as_number = {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1669 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
1670 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
1671 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
1672 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
1673 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
1674 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
1675 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
1676 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
1677 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
1678 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
1679 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
1680 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
1681 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
1682 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
1683 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
1684 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
1685 BF mpz_orfunc, /*nb_or*/
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1686 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
1687 #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
1688 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
1689 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
1690 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
1691 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
1692 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
1693 #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
1694 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1695
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1696 static PyTypeObject MPZtype = {
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1697 PyObject_HEAD_INIT(&PyType_Type)
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1698 0, /*ob_size*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1699 "mpz", /*tp_name*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1700 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
1701 0, /*tp_itemsize*/
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1702 /* methods */
1746
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1703 (destructor)mpz_dealloc, /*tp_dealloc*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1704 0, /*tp_print*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1705 (getattrfunc)mpz_getattr, /*tp_getattr*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1706 0, /*tp_setattr*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1707 (cmpfunc)mpz_compare, /*tp_compare*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1708 (reprfunc)mpz_repr, /*tp_repr*/
1940892d2fe3 Merge alpha100 branch back to main trunk
Guido van Rossum <guido@python.org>
parents: 1425
diff changeset
1709 &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
1710 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1711
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1712 /* 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
1713
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1714 static PyMethodDef mpz_functions[] = {
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1715 #if 0
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1716 {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
1717 #else /* 0 */
4645
68c4b06cfff7 Renamed a few symbols that were found in comments.
Barry Warsaw <barry@python.org>
parents: 4644
diff changeset
1718 /* until guido ``fixes'' struct PyMethodDef */
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1719 {(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
1720 #endif /* 0 else */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1721 {"powm", MPZ_powm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1722 {"gcd", MPZ_gcd},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1723 {"gcdext", MPZ_gcdext},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1724 {"sqrt", MPZ_sqrt},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1725 {"sqrtrem", MPZ_sqrtrem},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1726 {"divm", MPZ_divm},
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1727 {NULL, NULL} /* Sentinel */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1728 };
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1729
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1730
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1731 /* #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
1732
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1733 #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
1734 #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
1735 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
1736 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
1737 int *location;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1738 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1739 /* 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
1740 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
1741 fprintf(stderr, "MP_TEST_ERROR: location holds 0x%08d\n", *location );
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1742 Py_FatalError("MP_TEST_ERROR");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1743 } /* 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
1744 #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
1745 #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
1746 #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
1747 ; \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1748 else \
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1749 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
1750 #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
1751 #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
1752 #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
1753 #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
1754 #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
1755
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1756 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
1757 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
1758 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1759 void *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1760
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1761 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1762 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
1763 alloc_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1764 #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
1765
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1766 if ( (res = malloc(MP_EXTRA_ALLOC(alloc_size))) == NULL )
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1767 Py_FatalError("mp_allocate failure");
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1768
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1769 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1770 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
1771 #endif /* def MPZ_DEBUG */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1772
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1773 MP_SET_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
1774
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1775 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1776 } /* mp_allocate() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1777
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1778
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1779 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
1780 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1781 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
1782 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
1783 {
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1784 void *res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1785
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1786 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1787 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
1788 ptr, old_size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1789 #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
1790
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1791 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
1792
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1793 if ( (res = realloc(ptr, MP_EXTRA_ALLOC(new_size))) == NULL )
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1794 Py_FatalError("mp_reallocate failure");
1132
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_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
1798 res, new_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_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
1802
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1803 return res;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1804 } /* mp_reallocate() */
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 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
1808 void *ptr;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1809 size_t size;
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1810 {
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 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
1814 ptr, size);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1815 #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
1816
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1817 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
1818 free(ptr);
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1819 } /* mp_free() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1820
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1821
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1822
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1823 /* Initialize this module. */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1824
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1825 void
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1826 initmpz()
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 #ifdef MPZ_DEBUG
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1829 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
1830 #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
1831
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1832 mp_set_memory_functions( mp_allocate, mp_reallocate, mp_free );
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1833 (void)Py_InitModule("mpz", mpz_functions);
1132
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1834
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1835 /* 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
1836 if ((mpz_value_zero = newmpzobject()) == NULL)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1837 Py_FatalError("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
1838 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
1839
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1840 if ((mpz_value_one = newmpzobject()) == NULL)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1841 Py_FatalError("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
1842 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
1843
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1844 if ((mpz_value_mone = newmpzobject()) == NULL)
4644
f4ba9e07d9bf Renamed, ungrandly. We don't have the GNU MP library here so we can't
Barry Warsaw <barry@python.org>
parents: 4503
diff changeset
1845 Py_FatalError("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
1846 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
1847
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1848 } /* initmpz() */
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1849 #ifdef MAKEDUMMYINT
6461dac9a9f2 * mymalloc.h: always allocate one extra byte, since some malloc's
Guido van Rossum <guido@python.org>
parents:
diff changeset
1850 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
1851 #endif /* def MAKEDUMMYINT */