python-gmp 0.4.0b1__tar.gz → 0.4.0b2__tar.gz

{python_gmp-0.4.0b1 → python_gmp-0.4.0b2}/.github/workflows/os.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-24.04, macos-14]
+        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-14]
         shell: [bash]
 #       include:
 #         - os: windows-2022
@@ -40,6 +40,6 @@ jobs:
       - run: pip --verbose install .[tests] -Csetup-args=-Dbuildtype=debug
         env:
           PKG_CONFIG_PATH: .local/lib/pkgconfig
-      - run: pytest
+      - run: pytest --hypothesis-profile=default
         env:
           LD_LIBRARY_PATH: .local/lib

{python_gmp-0.4.0b1 → python_gmp-0.4.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-gmp
-Version: 0.4.0b1
+Version: 0.4.0b2
 Summary: Safe bindings to the GNU GMP library
 Keywords: gmp,multiple-precision,arbitrary-precision,bignum
 Author-Email: Sergey B Kirpichev <skirpichev@gmail.com>
@@ -52,13 +52,16 @@ Python-GMP
 ==========
 
 Python extension module providing safe bindings to the GNU GMP.  This module
-shouldn't crash the interpreter!  It requires Python 3.9 or later versions and
-has been tested with CPython 3.9 through 3.14 and for PyPy 3.10 and 3.11.
+shouldn't crash the interpreter!
 
 This module can be used as a gmpy2/python-flint replacement to provide
 CPython-compatible integer (mpz) type.  It includes few functions (factorial,
 gcd and isqrt), compatible with the stdlib's module math.
 
+It requires Python 3.9 or later versions and has been tested with CPython 3.9
+through 3.14, for PyPy 3.11 and for GraalPy 24.2.  Free-threading builds of the
+CPython are supported.
+
 Releases are available in the Python Package Index (PyPI) at
 https://pypi.org/project/python-gmp/
 

{python_gmp-0.4.0b1 → python_gmp-0.4.0b2}/README.rst

@@ -2,13 +2,16 @@ Python-GMP
 ==========
 
 Python extension module providing safe bindings to the GNU GMP.  This module
-shouldn't crash the interpreter!  It requires Python 3.9 or later versions and
-has been tested with CPython 3.9 through 3.14 and for PyPy 3.10 and 3.11.
+shouldn't crash the interpreter!
 
 This module can be used as a gmpy2/python-flint replacement to provide
 CPython-compatible integer (mpz) type.  It includes few functions (factorial,
 gcd and isqrt), compatible with the stdlib's module math.
 
+It requires Python 3.9 or later versions and has been tested with CPython 3.9
+through 3.14, for PyPy 3.11 and for GraalPy 24.2.  Free-threading builds of the
+CPython are supported.
+
 Releases are available in the Python Package Index (PyPI) at
 https://pypi.org/project/python-gmp/
 

{python_gmp-0.4.0b1 → python_gmp-0.4.0b2}/main.c

@@ -13,97 +13,17 @@
 #endif
 
 #include "mpz.h"
-#include "zz.h"
 
 #include <float.h>
-#include <gmp.h>
 #include <setjmp.h>
 #include <stdbool.h>
 
-extern jmp_buf gmp_env;
-
 #if !defined(_MSC_VER)
 #  define _Py_thread_local _Thread_local
 #else
 #  define _Py_thread_local __declspec(thread)
 #endif
 
-#define TRACKER_MAX_SIZE 64
-_Py_thread_local struct {
-    size_t size;
-    void *ptrs[TRACKER_MAX_SIZE];
-} gmp_tracker;
-
-static void *
-gmp_reallocate_function(void *ptr, size_t old_size, size_t new_size)
-{
-    if (gmp_tracker.size >= TRACKER_MAX_SIZE) {
-        goto err; /* LCOV_EXCL_LINE */
-    }
-    if (!ptr) {
-        void *ret = malloc(new_size);
-
-        if (!ret) {
-            goto err; /* LCOV_EXCL_LINE */
-        }
-        gmp_tracker.ptrs[gmp_tracker.size] = ret;
-        gmp_tracker.size++;
-        return ret;
-    }
-    size_t i = gmp_tracker.size - 1;
-
-    for (;; i--) {
-        if (gmp_tracker.ptrs[i] == ptr) {
-            break;
-        }
-    }
-
-    void *ret = realloc(ptr, new_size);
-
-    if (!ret) {
-        goto err; /* LCOV_EXCL_LINE */
-    }
-    gmp_tracker.ptrs[i] = ret;
-    return ret;
-err:
-    /* LCOV_EXCL_START */
-    for (size_t i = 0; i < gmp_tracker.size; i++) {
-        free(gmp_tracker.ptrs[i]);
-        gmp_tracker.ptrs[i] = NULL;
-    }
-    gmp_tracker.size = 0;
-    longjmp(gmp_env, 1);
-    /* LCOV_EXCL_STOP */
-}
-
-static void *
-gmp_allocate_function(size_t size)
-{
-    return gmp_reallocate_function(NULL, 0, size);
-}
-
-static void
-gmp_free_function(void *ptr, size_t size)
-{
-    for (size_t i = gmp_tracker.size - 1; i >= 0; i--) {
-        if (gmp_tracker.ptrs[i] == ptr) {
-            gmp_tracker.ptrs[i] = NULL;
-            break;
-        }
-    }
-    free(ptr);
-
-    size_t i = gmp_tracker.size - 1;
-
-    while (gmp_tracker.size > 0) {
-        if (gmp_tracker.ptrs[i]) {
-            break;
-        }
-        gmp_tracker.size--;
-        i--;
-    }
-}
-
 #if !defined(PYPY_VERSION) && !defined(Py_GIL_DISABLED)
 #  define CACHE_SIZE (99)
 #else
@@ -120,20 +40,14 @@ _Py_thread_local gmp_global global = {
     .gmp_cache_size = 0,
 };
 
-typedef struct {
-    void *(*default_allocate_func)(size_t);
-    void *(*default_reallocate_func)(void *, size_t, size_t);
-    void (*default_free_func)(void *, size_t);
-} gmp_state;
-
 static MPZ_Object *
-MPZ_new(mp_size_t size)
+MPZ_new(zz_size_t size)
 {
     MPZ_Object *res;
 
     if (global.gmp_cache_size && size <= MAX_CACHE_MPZ_LIMBS) {
         res = global.gmp_cache[--(global.gmp_cache_size)];
-        if (zz_resize(size, &res->z) == MP_MEM) {
+        if (zz_resize(size, &res->z) == ZZ_MEM) {
             /* LCOV_EXCL_START */
             global.gmp_cache[(global.gmp_cache_size)++] = res;
             return (MPZ_Object *)PyErr_NoMemory();
@@ -210,14 +124,14 @@ MPZ_to_str(MPZ_Object *u, int base, int options)
         (void)zz_abs(&u->z, &u->z);
     }
 
-    mp_err ret = zz_to_str(&u->z, base, p, &len);
+    zz_err ret = zz_to_str(&u->z, base, p, &len);
 
     if (ret) {
         if (cast_abs) {
             (void)zz_neg(&u->z, &u->z);
         }
         free(buf);
-        if (ret == MP_VAL) {
+        if (ret == ZZ_VAL) {
 bad_base:
             PyErr_SetString(PyExc_ValueError,
                             "mpz base must be >= 2 and <= 36");
@@ -315,15 +229,15 @@ skip_negation:
         len--;
     }
 
-    mp_err ret = zz_from_str(str, len, base, &res->z);
+    zz_err ret = zz_from_str(str, len, base, &res->z);
 
-    if (ret == MP_MEM) {
+    if (ret == ZZ_MEM) {
         /* LCOV_EXCL_START */
         Py_DECREF(res);
         return (MPZ_Object *)PyErr_NoMemory();
         /* LCOV_EXCL_STOP */
     }
-    else if (ret == MP_VAL) {
+    else if (ret == ZZ_VAL) {
         Py_DECREF(res);
         if (2 <= base && base <= 36) {
 err:
@@ -348,7 +262,7 @@ MPZ_from_int(PyObject *obj)
 {
 #if !defined(PYPY_VERSION) && !defined(GRAALVM_PYTHON)
     PyLongExport long_export = {0, 0, 0, 0, 0};
-    const mp_layout *int_layout = (mp_layout *)PyLong_GetNativeLayout();
+    const zz_layout *int_layout = (zz_layout *)PyLong_GetNativeLayout();
     MPZ_Object *res = NULL;
 
     if (PyLong_Export(obj, &long_export) < 0) {
@@ -404,12 +318,12 @@ MPZ_to_int(MPZ_Object *u)
 {
     int64_t value;
 
-    if (zz_to_i64(&u->z, &value) == MP_OK) {
+    if (zz_to_i64(&u->z, &value) == ZZ_OK) {
         return PyLong_FromInt64(value);
     }
 
 #if !defined(PYPY_VERSION) && !defined(GRAALVM_PYTHON)
-    const mp_layout *int_layout = (mp_layout *)PyLong_GetNativeLayout();
+    const zz_layout *int_layout = (zz_layout *)PyLong_GetNativeLayout();
     size_t size = (zz_bitlen(&u->z) + int_layout->bits_per_digit
                    - 1)/int_layout->bits_per_digit;
     void *digits;
@@ -435,7 +349,7 @@ MPZ_to_int(MPZ_Object *u)
 }
 
 static MPZ_Object *
-MPZ_rshift1(const MPZ_Object *u, mp_limb_t rshift)
+MPZ_rshift1(const MPZ_Object *u, zz_limb_t rshift)
 {
     MPZ_Object *res = MPZ_new(0);
 
@@ -471,16 +385,16 @@ MPZ_to_bytes(MPZ_Object *u, Py_ssize_t length, int is_little, int is_signed)
     }
 
     uint8_t *buffer = (uint8_t *)PyBytes_AS_STRING(bytes);
-    mp_err ret = zz_to_bytes(&u->z, length, is_signed, &buffer);
+    zz_err ret = zz_to_bytes(&u->z, length, is_signed, &buffer);
 
-    if (ret == MP_OK) {
+    if (ret == ZZ_OK) {
         if (is_little && length) {
             revstr(buffer, 0, length - 1);
         }
         return bytes;
     }
     Py_DECREF(bytes);
-    if (ret == MP_BUF) {
+    if (ret == ZZ_BUF) {
         if (zz_isneg(&u->z) && !is_signed) {
             PyErr_SetString(PyExc_OverflowError,
                             "can't convert negative mpz to unsigned");
@@ -877,9 +791,9 @@ to_float(PyObject *self)
 {
     double d;
     MPZ_Object *u = (MPZ_Object *)self;
-    mp_err ret = zz_to_double(&u->z, &d);
+    zz_err ret = zz_to_double(&u->z, &d);
 
-    if (ret == MP_BUF) {
+    if (ret == ZZ_BUF) {
         PyErr_SetString(PyExc_OverflowError,
                         "integer too large to convert to float");
         return NULL;
@@ -895,23 +809,23 @@ richcompare(PyObject *self, PyObject *other, int op)
     CHECK_OP(u, self);
     CHECK_OP(v, other);
 
-    mp_ord r = zz_cmp(&u->z, &v->z);
+    zz_ord r = zz_cmp(&u->z, &v->z);
 
     Py_XDECREF(u);
     Py_XDECREF(v);
     switch (op) {
         case Py_LT:
-            return PyBool_FromLong(r == MP_LT);
+            return PyBool_FromLong(r == ZZ_LT);
         case Py_LE:
-            return PyBool_FromLong(r != MP_GT);
+            return PyBool_FromLong(r != ZZ_GT);
         case Py_GT:
-            return PyBool_FromLong(r == MP_GT);
+            return PyBool_FromLong(r == ZZ_GT);
         case Py_GE:
-            return PyBool_FromLong(r != MP_LT);
+            return PyBool_FromLong(r != ZZ_LT);
         case Py_EQ:
-            return PyBool_FromLong(r == MP_EQ);
+            return PyBool_FromLong(r == ZZ_EQ);
         case Py_NE:
-            return PyBool_FromLong(r != MP_EQ);
+            return PyBool_FromLong(r != ZZ_EQ);
     }
     /* LCOV_EXCL_START */
     Py_RETURN_NOTIMPLEMENTED;
@@ -1004,16 +918,16 @@ to_bool(PyObject *self)
         CHECK_OP(v, other);                                     \
                                                                 \
         res = MPZ_new(0);                                    \
-        mp_err ret = MP_OK;                                     \
+        zz_err ret = ZZ_OK;                                     \
                                                                 \
         if (!res || (ret = zz_##suff(&u->z, &v->z, &res->z))) { \
             /* LCOV_EXCL_START */                               \
             Py_CLEAR(res);                                      \
-            if (ret == MP_VAL) {                                \
+            if (ret == ZZ_VAL) {                                \
                 PyErr_SetString(PyExc_ValueError,               \
                                 "negative shift count");        \
             }                                                   \
-            else if (ret == MP_BUF) {                           \
+            else if (ret == ZZ_BUF) {                           \
                 PyErr_SetString(PyExc_OverflowError,            \
                                 "too many digits in integer");  \
             }                                                   \
@@ -1048,13 +962,13 @@ to_bool(PyObject *self)
             goto end;                                    \
         }                                                \
                                                          \
-        mp_err ret = zz_##suff(&u->z, &v->z,             \
+        zz_err ret = zz_##suff(&u->z, &v->z,             \
                                &((MPZ_Object *)res)->z); \
                                                          \
-        if (ret == MP_OK) {                              \
+        if (ret == ZZ_OK) {                              \
             goto end;                                    \
         }                                                \
-        if (ret == MP_VAL) {                             \
+        if (ret == ZZ_VAL) {                             \
             Py_CLEAR(res);                               \
             PyErr_SetString(PyExc_ZeroDivisionError,     \
                             "division by zero");         \
@@ -1108,16 +1022,16 @@ BINOP(add, PyNumber_Add)
 BINOP(sub, PyNumber_Subtract)
 BINOP(mul, PyNumber_Multiply)
 
-static mp_err
+static zz_err
 zz_quo(const zz_t *u, const zz_t *v, zz_t *w)
 {
-    return zz_div(u, v, MP_RNDD, w, NULL);
+    return zz_div(u, v, ZZ_RNDD, w, NULL);
 }
 
-static mp_err
+static zz_err
 zz_rem(const zz_t *u, const zz_t *v, zz_t *w)
 {
-    return zz_div(u, v, MP_RNDD, NULL, w);
+    return zz_div(u, v, ZZ_RNDD, NULL, w);
 }
 
 BINOP(quo, PyNumber_FloorDivide)
@@ -1146,12 +1060,12 @@ nb_divmod(PyObject *self, PyObject *other)
         /* LCOV_EXCL_STOP */
     }
 
-    mp_err ret = zz_div(&u->z, &v->z, MP_RNDD, &q->z, &r->z);
+    zz_err ret = zz_div(&u->z, &v->z, ZZ_RNDD, &q->z, &r->z);
 
     if (ret) {
         Py_DECREF(q);
         Py_DECREF(r);
-        if (ret == MP_VAL) {
+        if (ret == ZZ_VAL) {
             PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");
         }
         else {
@@ -1190,16 +1104,16 @@ nb_truediv(PyObject *self, PyObject *other)
 
     double d;
 
-    mp_err ret = zz_truediv(&u->z, &v->z, &d);
+    zz_err ret = zz_truediv(&u->z, &v->z, &d);
 
-    if (ret == MP_OK) {
+    if (ret == ZZ_OK) {
         res = PyFloat_FromDouble(d);
         goto end;
     }
-    if (ret == MP_VAL) {
+    if (ret == ZZ_VAL) {
         PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");
     }
-    else if (ret == MP_BUF) {
+    else if (ret == ZZ_BUF) {
         PyErr_SetString(PyExc_OverflowError,
                         "integer too large to convert to float");
     }
@@ -1249,26 +1163,26 @@ numbers:
     return res;
 }
 
-static mp_err
+static zz_err
 zz_lshift(const zz_t *u, const zz_t *v, zz_t *w)
 {
-    if (v->negative) {
-        return MP_VAL;
+    if (zz_isneg(v)) {
+        return ZZ_VAL;
     }
     if (v->size > 1) {
-        return MP_BUF;
+        return ZZ_BUF;
     }
     return zz_mul_2exp(u, v->size ? v->digits[0] : 0, w);
 }
 
-static mp_err
+static zz_err
 zz_rshift(const zz_t *u, const zz_t *v, zz_t *w)
 {
-    if (v->negative) {
-        return MP_VAL;
+    if (zz_isneg(v)) {
+        return ZZ_VAL;
     }
     if (v->size > 1) {
-        return zz_from_i32(u->negative ? -1 : 0, w);
+        return zz_from_i32(zz_isneg(u) ? -1 : 0, w);
     }
     return zz_quo_2exp(u, v->size ? v->digits[0] : 0, w);
 }
@@ -1342,12 +1256,12 @@ power(PyObject *self, PyObject *other, PyObject *module)
             goto end;
         }
 
-        mp_err ret = MP_OK;
+        zz_err ret = ZZ_OK;
 
         res = MPZ_new(0);
         if (!res || (ret = zz_powm(&u->z, &v->z, &w->z, &res->z))) {
             /* LCOV_EXCL_START */
-            if (ret == MP_VAL) {
+            if (ret == ZZ_VAL) {
                 PyErr_SetString(PyExc_ValueError,
                                 "base is not invertible for the given modulus");
             }
@@ -1465,7 +1379,7 @@ static PyObject *
 bit_length(PyObject *self, PyObject *Py_UNUSED(args))
 {
     MPZ_Object *u = (MPZ_Object *)self;
-    mp_limb_t digit = zz_bitlen(&u->z);
+    zz_limb_t digit = zz_bitlen(&u->z);
 
     return PyLong_FromUnsignedLongLong(digit);
 }
@@ -1474,7 +1388,7 @@ static PyObject *
 bit_count(PyObject *self, PyObject *Py_UNUSED(args))
 {
     MPZ_Object *u = (MPZ_Object *)self;
-    mp_bitcnt_t count = zz_bitcnt(&u->z);
+    zz_bitcnt_t count = zz_bitcnt(&u->z);
 
     return PyLong_FromUnsignedLongLong(count);
 }
@@ -1688,7 +1602,7 @@ __round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         return NULL;
         /* LCOV_EXCL_STOP */
     }
-    if (zz_div(&u->z, &((MPZ_Object *)p)->z, MP_RNDN, NULL, &r->z)) {
+    if (zz_div(&u->z, &((MPZ_Object *)p)->z, ZZ_RNDN, NULL, &r->z)) {
         /* LCOV_EXCL_START */
         Py_DECREF(r);
         return PyErr_NoMemory();
@@ -1726,7 +1640,7 @@ __sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
     MPZ_Object *u = (MPZ_Object *)self;
 
     return PyLong_FromSize_t(sizeof(MPZ_Object)
-                             + (u->z).alloc*sizeof(mp_limb_t));
+                             + (u->z).alloc*sizeof(zz_limb_t));
 }
 
 static PyObject *
@@ -1919,7 +1833,7 @@ gmp_gcd(PyObject *Py_UNUSED(module), PyObject *const *args, Py_ssize_t nargs)
                             "gcd() arguments must be integers");
             return NULL;
         }
-        if (zz_cmp_i32(&res->z, 1) == MP_EQ) {
+        if (zz_cmp_i32(&res->z, 1) == ZZ_EQ) {
             Py_DECREF(arg);
             continue;
         }
@@ -1987,11 +1901,11 @@ gmp_gcdext(PyObject *Py_UNUSED(module), PyObject *const *args,
         goto err;
     }
 
-    mp_err ret = zz_gcdext(&x->z, &y->z, &g->z, &s->z, &t->z);
+    zz_err ret = zz_gcdext(&x->z, &y->z, &g->z, &s->z, &t->z);
 
     Py_XDECREF(x);
     Py_XDECREF(y);
-    if (ret == MP_MEM) {
+    if (ret == ZZ_MEM) {
         PyErr_NoMemory(); /* LCOV_EXCL_LINE */
     }
     PyObject *tup = PyTuple_Pack(3, g, s, t);
@@ -2033,17 +1947,17 @@ gmp_isqrt(PyObject *Py_UNUSED(module), PyObject *arg)
         goto err;
     }
 
-    mp_err ret = zz_sqrtrem(&x->z, &root->z, NULL);
+    zz_err ret = zz_sqrtrem(&x->z, &root->z, NULL);
 
     Py_DECREF(x);
-    if (ret == MP_OK) {
+    if (ret == ZZ_OK) {
         return (PyObject *)root;
     }
-    if (ret == MP_VAL) {
+    if (ret == ZZ_VAL) {
         PyErr_SetString(PyExc_ValueError,
                         "isqrt() argument must be nonnegative");
     }
-    if (ret == MP_MEM) {
+    if (ret == ZZ_MEM) {
         PyErr_NoMemory(); /* LCOV_EXCL_LINE */
     }
 err:
@@ -2080,17 +1994,17 @@ gmp_isqrt_rem(PyObject *Py_UNUSED(module), PyObject *arg)
         goto err;
     }
 
-    mp_err ret = zz_sqrtrem(&x->z, &root->z, &rem->z);
+    zz_err ret = zz_sqrtrem(&x->z, &root->z, &rem->z);
 
     Py_DECREF(x);
-    if (ret == MP_OK) {
+    if (ret == ZZ_OK) {
         tup = PyTuple_Pack(2, root, rem);
     }
-    if (ret == MP_VAL) {
+    if (ret == ZZ_VAL) {
         PyErr_SetString(PyExc_ValueError,
                         "isqrt() argument must be nonnegative");
     }
-    if (ret == MP_MEM) {
+    if (ret == ZZ_MEM) {
         PyErr_NoMemory(); /* LCOV_EXCL_LINE */
     }
 err:
@@ -2155,7 +2069,7 @@ MAKE_MPZ_UI_FUN(fac2)
 MAKE_MPZ_UI_FUN(fib)
 
 static PyObject *
-build_mpf(long sign, MPZ_Object *man, PyObject *exp, mp_bitcnt_t bc)
+build_mpf(long sign, MPZ_Object *man, PyObject *exp, zz_bitcnt_t bc)
 {
     PyObject *tup, *tsign, *tbc;
 
@@ -2194,10 +2108,10 @@ build_mpf(long sign, MPZ_Object *man, PyObject *exp, mp_bitcnt_t bc)
 }
 
 static PyObject *
-normalize_mpf(long sign, MPZ_Object *man, PyObject *exp, mp_bitcnt_t bc,
-              mp_bitcnt_t prec, Py_UCS4 rnd)
+normalize_mpf(long sign, MPZ_Object *man, PyObject *exp, zz_bitcnt_t bc,
+              zz_bitcnt_t prec, Py_UCS4 rnd)
 {
-    mp_bitcnt_t zbits = 0;
+    zz_bitcnt_t zbits = 0;
     PyObject *newexp = NULL, *tmp = NULL;
     MPZ_Object *res = NULL;
 
@@ -2214,7 +2128,7 @@ normalize_mpf(long sign, MPZ_Object *man, PyObject *exp, mp_bitcnt_t bc,
     }
     Py_INCREF(exp);
     if (bc > prec) {
-        mp_bitcnt_t shift = bc - prec;
+        zz_bitcnt_t shift = bc - prec;
 
         switch (rnd) {
             case (Py_UCS4)'f':
@@ -2311,7 +2225,7 @@ normalize_mpf(long sign, MPZ_Object *man, PyObject *exp, mp_bitcnt_t bc,
 
     bc -= zbits;
     /* Check if one less than a power of 2 was rounded up. */
-    if (zz_cmp_i32(&res->z, 1) == MP_EQ) {
+    if (zz_cmp_i32(&res->z, 1) == ZZ_EQ) {
         bc = 1;
     }
     return build_mpf(sign, res, exp, bc);
@@ -2328,11 +2242,11 @@ gmp__mpmath_normalize(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     long sign = PyLong_AsLong(args[0]);
     MPZ_Object *man = (MPZ_Object *)args[1];
     PyObject *exp = args[2];
-    mp_bitcnt_t bc = PyLong_AsUnsignedLongLong(args[3]);
-    mp_bitcnt_t prec = PyLong_AsUnsignedLongLong(args[4]);
+    zz_bitcnt_t bc = PyLong_AsUnsignedLongLong(args[3]);
+    zz_bitcnt_t prec = PyLong_AsUnsignedLongLong(args[4]);
     PyObject *rndstr = args[5];
 
-    if (sign == -1 || bc == (mp_bitcnt_t)(-1) || prec == (mp_bitcnt_t)(-1)
+    if (sign == -1 || bc == (zz_bitcnt_t)(-1) || prec == (zz_bitcnt_t)(-1)
         || !MPZ_Check(man))
     {
         PyErr_SetString(PyExc_TypeError,
@@ -2382,13 +2296,13 @@ gmp__mpmath_create(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         (void)zz_abs(&man->z, &man->z);
     }
 
-    mp_bitcnt_t bc = zz_bitlen(&man->z);
-    mp_bitcnt_t prec = 0;
+    zz_bitcnt_t bc = zz_bitlen(&man->z);
+    zz_bitcnt_t prec = 0;
     Py_UCS4 rnd = 'd';
 
     if (nargs > 2) {
         prec = PyLong_AsUnsignedLongLong(args[2]);
-        if (prec == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
+        if (prec == (zz_bitcnt_t)(-1) && PyErr_Occurred()) {
             PyErr_SetString(PyExc_TypeError, "bad prec argument");
             return NULL;
         }
@@ -2409,7 +2323,7 @@ gmp__mpmath_create(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
             return build_mpf(0, man, 0, 0);
         }
 
-        mp_bitcnt_t zbits = 0;
+        zz_bitcnt_t zbits = 0;
         PyObject *tmp, *newexp;
 
         /* Strip trailing 0 bits. */
@@ -2501,13 +2415,12 @@ static PyStructSequence_Desc gmp_info_desc = {
 static int
 gmp_exec(PyObject *m)
 {
-    gmp_state *state = PyModule_GetState(m);
+    uint8_t gmp_limb_bits;
+    char *gmp_version;
 
-    mp_get_memory_functions(&state->default_allocate_func,
-                            &state->default_reallocate_func,
-                            &state->default_free_func);
-    mp_set_memory_functions(gmp_allocate_function, gmp_reallocate_function,
-                            gmp_free_function);
+    if (zz_setup(&gmp_limb_bits, &gmp_version)) {
+        return -1; /* LCOV_EXCL_LINE */
+    }
     if (PyModule_AddType(m, &MPZ_Type) < 0) {
         return -1; /* LCOV_EXCL_LINE */
     }
@@ -2524,8 +2437,9 @@ gmp_exec(PyObject *m)
     if (gmp_info == NULL) {
         return -1; /* LCOV_EXCL_LINE */
     }
-    PyStructSequence_SET_ITEM(gmp_info, 0, PyLong_FromLong(GMP_LIMB_BITS));
-    PyStructSequence_SET_ITEM(gmp_info, 1, PyLong_FromLong(sizeof(mp_limb_t)));
+    PyStructSequence_SET_ITEM(gmp_info, 0, PyLong_FromLong(gmp_limb_bits));
+    PyStructSequence_SET_ITEM(gmp_info, 1,
+                              PyLong_FromLong((gmp_limb_bits + 7)/8));
     PyStructSequence_SET_ITEM(gmp_info, 2, PyUnicode_FromString(gmp_version));
     if (PyErr_Occurred()) {
         /* LCOV_EXCL_START */
@@ -2569,13 +2483,9 @@ gmp_exec(PyObject *m)
 }
 
 static int
-gmp_clear(PyObject *module)
+gmp_clear(PyObject *Py_UNUSED(module))
 {
-    gmp_state *state = (gmp_state *)PyModule_GetState(module);
-
-    mp_set_memory_functions(state->default_allocate_func,
-                            state->default_reallocate_func,
-                            state->default_free_func);
+    zz_finish();
     return 0;
 }
 
@@ -2606,7 +2516,7 @@ static struct PyModuleDef gmp_module = {
     PyModuleDef_HEAD_INIT,
     .m_name = "gmp",
     .m_doc = "Bindings to the GNU GMP for Python.",
-    .m_size = sizeof(gmp_state),
+    .m_size = 0,
     .m_methods = gmp_functions,
     .m_slots = gmp_slots,
     .m_free = gmp_free,