[src,tests] Consistency: in prototypes, changed

  const mpfr_t          to  mpfr_srcptr,
  mpfr_t                to  mpfr_ptr,
  mpz_t                 to  mpz_ptr,
  mpfr_random_deviate_t to mpfr_random_deviate_ptr,
in order to silence a warning from the future GCC 11 -Warray-parameter
option (included in -Wall).

This warning was making the MPFR build fail in combination with -Werror
(useful for testing), and there was no simple way to get rid of it in a
way independent of the GCC version (due to GCC bug 86134 / 99014, which
could also silently change the detected features in configure tests).
And as this inconsistency was also present in mpfr.h, this fix may also
benefit the build of software that uses MPFR.

(merged changesets r14103,14154 from the trunk)

git-svn-id: https://scm.gforge.inria.fr/anonscm/svn/mpfr/branches/4.1@14411 280ebfd0-de03-0410-8827-d642c229c3f4

35 files changed, 82 insertions, 76 deletions

diff --git a/src/atan.c b/src/atan.c
index 9b557899c..ffe4a867a 100644
--- a/src/atan.c
+++ b/src/atan.c
@@ -56,7 +56,7 @@ static const mp_limb_t atan_table[][3] = {
   };
 
 static void
-set_table (mpfr_t y, const mp_limb_t x[3])
+set_table (mpfr_ptr y, const mp_limb_t x[3])
 {
   mpfr_prec_t p = MPFR_PREC(y);
   mp_size_t n = MPFR_PREC2LIMBS(p);
diff --git a/src/const_euler.c b/src/const_euler.c
index b4a6deb04..8bf9e03c0 100644
--- a/src/const_euler.c
+++ b/src/const_euler.c
@@ -181,7 +181,7 @@ mpfr_const_euler_bs_2 (mpz_t P, mpz_t Q, mpz_t T,
 }
 
 int
-mpfr_const_euler_internal (mpfr_t x, mpfr_rnd_t rnd)
+mpfr_const_euler_internal (mpfr_ptr x, mpfr_rnd_t rnd)
 {
   mpfr_const_euler_bs_t sum;
   mpz_t t, u, v;
diff --git a/src/eint.c b/src/eint.c
index 1d1d96a37..3045c82f6 100644
--- a/src/eint.c
+++ b/src/eint.c
@@ -36,7 +36,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
    Return PREC(y) when the truncated series does not converge.
 */
 static mpfr_exp_t
-mpfr_eint_aux (mpfr_t y, mpfr_srcptr x)
+mpfr_eint_aux (mpfr_ptr y, mpfr_srcptr x)
 {
   mpfr_t eps; /* dynamic (absolute) error bound on t */
   mpfr_t erru, errs;
diff --git a/src/erandom.c b/src/erandom.c
index e3d942c4b..fc18611ab 100644
--- a/src/erandom.c
+++ b/src/erandom.c
@@ -80,7 +80,7 @@ E (mpfr_random_deviate_t x, gmp_randstate_t r,
 
 /* return an exponential random deviate with mean 1 as a MPFR  */
 int
-mpfr_erandom (mpfr_t z, gmp_randstate_t r, mpfr_rnd_t rnd)
+mpfr_erandom (mpfr_ptr z, gmp_randstate_t r, mpfr_rnd_t rnd)
 {
   mpfr_random_deviate_t x, p, q;
   int inex;
diff --git a/src/fpif.c b/src/fpif.c
index a97cdcb53..92541f90f 100644
--- a/src/fpif.c
+++ b/src/fpif.c
@@ -291,7 +291,8 @@ mpfr_fpif_read_precision_from_file (FILE *fh)
  *   until one has integer types larger than 128 bits).
  */
 static unsigned char*
-mpfr_fpif_store_exponent (unsigned char *buffer, size_t *buffer_size, mpfr_t x)
+mpfr_fpif_store_exponent (unsigned char *buffer, size_t *buffer_size,
+                          mpfr_ptr x)
 {
   unsigned char *result;
   mpfr_uexp_t uexp;
@@ -372,7 +373,7 @@ mpfr_fpif_store_exponent (unsigned char *buffer, size_t *buffer_size, mpfr_t x)
  *   than 128 bits).
  */
 static int
-mpfr_fpif_read_exponent_from_file (mpfr_t x, FILE * fh)
+mpfr_fpif_read_exponent_from_file (mpfr_ptr x, FILE * fh)
 {
   mpfr_exp_t exponent;
   mpfr_uexp_t uexp;
@@ -456,7 +457,7 @@ mpfr_fpif_read_exponent_from_file (mpfr_t x, FILE * fh)
  *        format
  */
 static unsigned char*
-mpfr_fpif_store_limbs (unsigned char *buffer, size_t *buffer_size, mpfr_t x)
+mpfr_fpif_store_limbs (unsigned char *buffer, size_t *buffer_size, mpfr_ptr x)
 {
   unsigned char *result;
   mpfr_prec_t precision;
@@ -492,7 +493,7 @@ mpfr_fpif_store_limbs (unsigned char *buffer, size_t *buffer_size, mpfr_t x)
  * Assume buffer is not NULL.
  */
 static void
-mpfr_fpif_read_limbs (mpfr_t x, unsigned char *buffer, size_t nb_byte)
+mpfr_fpif_read_limbs (mpfr_ptr x, unsigned char *buffer, size_t nb_byte)
 {
   size_t mp_bytes_per_limb;
   size_t nb_partial_byte;
@@ -522,7 +523,7 @@ mpfr_fpif_read_limbs (mpfr_t x, unsigned char *buffer, size_t nb_byte)
  * return 0 if successful
  */
 int
-mpfr_fpif_export (FILE *fh, mpfr_t x)
+mpfr_fpif_export (FILE *fh, mpfr_ptr x)
 {
   int status;
   unsigned char *buf;
@@ -582,7 +583,7 @@ mpfr_fpif_export (FILE *fh, mpfr_t x)
  * Return 0 if the import was successful.
  */
 int
-mpfr_fpif_import (mpfr_t x, FILE *fh)
+mpfr_fpif_import (mpfr_ptr x, FILE *fh)
 {
   int status;
   mpfr_prec_t precision;
diff --git a/src/li2.c b/src/li2.c
index 6b61012ac..c25f437bb 100644
--- a/src/li2.c
+++ b/src/li2.c
@@ -31,7 +31,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
    for determinating the relative error.
 */
 static int
-li2_series (mpfr_t sum, mpfr_srcptr z, mpfr_rnd_t rnd_mode)
+li2_series (mpfr_ptr sum, mpfr_srcptr z, mpfr_rnd_t rnd_mode)
 {
   int i;
   mpfr_t s, u, v, w;
diff --git a/src/lngamma.c b/src/lngamma.c
index 5f4dca15f..a5bf50f7f 100644
--- a/src/lngamma.c
+++ b/src/lngamma.c
@@ -31,7 +31,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
    precision should be >= 4.
 */
 static void
-mpfr_gamma_alpha (mpfr_t s, mpfr_prec_t p)
+mpfr_gamma_alpha (mpfr_ptr s, mpfr_prec_t p)
 {
   MPFR_LOG_FUNC
     (("p=%Pu", p),
diff --git a/src/mpfr-impl.h b/src/mpfr-impl.h
index 211ffdf45..80cecbc2b 100644
--- a/src/mpfr-impl.h
+++ b/src/mpfr-impl.h
@@ -2474,7 +2474,8 @@ __MPFR_DECLSPEC void mpfr_rand_raw (mpfr_limb_ptr, gmp_randstate_t,
 __MPFR_DECLSPEC mpz_srcptr mpfr_bernoulli_cache (unsigned long);
 __MPFR_DECLSPEC void mpfr_bernoulli_freecache (void);
 
-__MPFR_DECLSPEC int mpfr_sincos_fast (mpfr_t, mpfr_t, mpfr_srcptr, mpfr_rnd_t);
+__MPFR_DECLSPEC int mpfr_sincos_fast (mpfr_ptr, mpfr_ptr, mpfr_srcptr,
+                                      mpfr_rnd_t);
 
 __MPFR_DECLSPEC double mpfr_scale2 (double, int);
 
@@ -2485,7 +2486,7 @@ __MPFR_DECLSPEC void mpfr_gamma_one_and_two_third (mpfr_ptr, mpfr_ptr,
                                                    mpfr_prec_t);
 
 __MPFR_DECLSPEC void mpfr_mpz_init (mpz_ptr);
-__MPFR_DECLSPEC void mpfr_mpz_init2 (mpz_t, mp_bitcnt_t);
+__MPFR_DECLSPEC void mpfr_mpz_init2 (mpz_ptr, mp_bitcnt_t);
 __MPFR_DECLSPEC void mpfr_mpz_clear (mpz_ptr);
 
 __MPFR_DECLSPEC int mpfr_odd_p (mpfr_srcptr);
diff --git a/src/mpfr.h b/src/mpfr.h
index 59bb9db01..beea0c605 100644
--- a/src/mpfr.h
+++ b/src/mpfr.h
@@ -781,8 +781,8 @@ __MPFR_DECLSPEC int mpfr_subnormalize (mpfr_ptr, int, mpfr_rnd_t);
 __MPFR_DECLSPEC int mpfr_strtofr (mpfr_ptr, const char *, char **, int,
                                   mpfr_rnd_t);
 
-__MPFR_DECLSPEC void mpfr_round_nearest_away_begin (mpfr_t);
-__MPFR_DECLSPEC int mpfr_round_nearest_away_end (mpfr_t, int);
+__MPFR_DECLSPEC void mpfr_round_nearest_away_begin (mpfr_ptr);
+__MPFR_DECLSPEC int mpfr_round_nearest_away_end (mpfr_ptr, int);
 
 __MPFR_DECLSPEC size_t mpfr_custom_get_size (mpfr_prec_t);
 __MPFR_DECLSPEC void mpfr_custom_init (void *, mpfr_prec_t);
@@ -1080,10 +1080,12 @@ extern "C" {
 #define mpfr_set_uj_2exp __gmpfr_set_uj_2exp
 #define mpfr_get_sj __gmpfr_mpfr_get_sj
 #define mpfr_get_uj __gmpfr_mpfr_get_uj
-__MPFR_DECLSPEC int mpfr_set_sj (mpfr_t, intmax_t, mpfr_rnd_t);
-__MPFR_DECLSPEC int mpfr_set_sj_2exp (mpfr_t, intmax_t, intmax_t, mpfr_rnd_t);
-__MPFR_DECLSPEC int mpfr_set_uj (mpfr_t, uintmax_t, mpfr_rnd_t);
-__MPFR_DECLSPEC int mpfr_set_uj_2exp (mpfr_t, uintmax_t, intmax_t, mpfr_rnd_t);
+__MPFR_DECLSPEC int mpfr_set_sj (mpfr_ptr, intmax_t, mpfr_rnd_t);
+__MPFR_DECLSPEC int mpfr_set_sj_2exp (mpfr_ptr, intmax_t, intmax_t,
+                                      mpfr_rnd_t);
+__MPFR_DECLSPEC int mpfr_set_uj (mpfr_ptr, uintmax_t, mpfr_rnd_t);
+__MPFR_DECLSPEC int mpfr_set_uj_2exp (mpfr_ptr, uintmax_t, intmax_t,
+                                      mpfr_rnd_t);
 __MPFR_DECLSPEC intmax_t mpfr_get_sj (mpfr_srcptr, mpfr_rnd_t);
 __MPFR_DECLSPEC uintmax_t mpfr_get_uj (mpfr_srcptr, mpfr_rnd_t);
 
diff --git a/src/nrandom.c b/src/nrandom.c
index 1fe694092..2b2b98a66 100644
--- a/src/nrandom.c
+++ b/src/nrandom.c
@@ -155,7 +155,7 @@ B (unsigned long k, mpfr_random_deviate_t x, gmp_randstate_t r,
 
 /* return a normal random deviate with mean 0 and variance 1 as a MPFR  */
 int
-mpfr_nrandom (mpfr_t z, gmp_randstate_t r, mpfr_rnd_t rnd)
+mpfr_nrandom (mpfr_ptr z, gmp_randstate_t r, mpfr_rnd_t rnd)
 {
   mpfr_random_deviate_t x, p, q;
   int inex;
diff --git a/src/pool.c b/src/pool.c
index 7a68cbf9b..43f4f600e 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -35,7 +35,7 @@ static MPFR_THREAD_ATTR int n_alloc = 0;
 static MPFR_THREAD_ATTR __mpz_struct mpz_tab[MPFR_POOL_NENTRIES];
 
 MPFR_HOT_FUNCTION_ATTR void
-mpfr_mpz_init (mpz_t z)
+mpfr_mpz_init (mpz_ptr z)
 {
   if (MPFR_LIKELY (n_alloc > 0))
     {
@@ -54,7 +54,7 @@ mpfr_mpz_init (mpz_t z)
 }
 
 MPFR_HOT_FUNCTION_ATTR void
-mpfr_mpz_init2 (mpz_t z, mp_bitcnt_t n)
+mpfr_mpz_init2 (mpz_ptr z, mp_bitcnt_t n)
 {
   /* The condition on n is used below as the argument n will be ignored if
      the mpz_t is obtained from the MPFR stack of previously used mpz_t.
@@ -82,7 +82,7 @@ mpfr_mpz_init2 (mpz_t z, mp_bitcnt_t n)
 
 
 MPFR_HOT_FUNCTION_ATTR void
-mpfr_mpz_clear (mpz_t z)
+mpfr_mpz_clear (mpz_ptr z)
 {
   /* We only put objects with at most MPFR_POOL_MAX_SIZE in the mpz_t pool,
      to avoid it takes too much memory (and anyway the speedup is mainly
diff --git a/src/random_deviate.c b/src/random_deviate.c
index 817cb3ad7..2801b341a 100644
--- a/src/random_deviate.c
+++ b/src/random_deviate.c
@@ -64,7 +64,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 
 /* allocate and set to (0,1) */
 void
-mpfr_random_deviate_init (mpfr_random_deviate_t x)
+mpfr_random_deviate_init (mpfr_random_deviate_ptr x)
 {
   mpz_init (x->f);
   x->e = 0;
@@ -72,21 +72,22 @@ mpfr_random_deviate_init (mpfr_random_deviate_t x)
 
 /* reset to (0,1) */
 void
-mpfr_random_deviate_reset (mpfr_random_deviate_t x)
+mpfr_random_deviate_reset (mpfr_random_deviate_ptr x)
 {
   x->e = 0;
 }
 
 /* deallocate */
 void
-mpfr_random_deviate_clear (mpfr_random_deviate_t x)
+mpfr_random_deviate_clear (mpfr_random_deviate_ptr x)
 {
   mpz_clear (x->f);
 }
 
 /* swap two random deviates */
 void
-mpfr_random_deviate_swap (mpfr_random_deviate_t x, mpfr_random_deviate_t y)
+mpfr_random_deviate_swap (mpfr_random_deviate_ptr x,
+                          mpfr_random_deviate_ptr y)
 {
   mpfr_random_size_t s;
   unsigned long t;
@@ -107,7 +108,7 @@ mpfr_random_deviate_swap (mpfr_random_deviate_t x, mpfr_random_deviate_t y)
 
 /* ensure x has at least k bits */
 static void
-random_deviate_generate (mpfr_random_deviate_t x, mpfr_random_size_t k,
+random_deviate_generate (mpfr_random_deviate_ptr x, mpfr_random_size_t k,
                          gmp_randstate_t r, mpz_t t)
 {
   /* Various compile time checks on mpfr_random_deviate_t */
@@ -223,7 +224,7 @@ highest_bit_idx (unsigned long x)
 
 /* return position of leading bit, counting from 1 */
 static mpfr_random_size_t
-random_deviate_leading_bit (mpfr_random_deviate_t x, gmp_randstate_t r)
+random_deviate_leading_bit (mpfr_random_deviate_ptr x, gmp_randstate_t r)
 {
   mpfr_random_size_t l;
   random_deviate_generate (x, W, r, 0);
@@ -243,7 +244,7 @@ random_deviate_leading_bit (mpfr_random_deviate_t x, gmp_randstate_t r)
 
 /* return kth bit of fraction, representing 2^-k */
 int
-mpfr_random_deviate_tstbit (mpfr_random_deviate_t x, mpfr_random_size_t k,
+mpfr_random_deviate_tstbit (mpfr_random_deviate_ptr x, mpfr_random_size_t k,
                             gmp_randstate_t r)
 {
   if (k == 0)
@@ -256,7 +257,8 @@ mpfr_random_deviate_tstbit (mpfr_random_deviate_t x, mpfr_random_size_t k,
 
 /* compare two random deviates, x < y */
 int
-mpfr_random_deviate_less (mpfr_random_deviate_t x, mpfr_random_deviate_t y,
+mpfr_random_deviate_less (mpfr_random_deviate_ptr x,
+                          mpfr_random_deviate_ptr y,
                           gmp_randstate_t r)
 {
   mpfr_random_size_t k = 1;
@@ -280,7 +282,7 @@ mpfr_random_deviate_less (mpfr_random_deviate_t x, mpfr_random_deviate_t y,
 /* set mpfr_t z = (neg ? -1 : 1) * (n + x) */
 int
 mpfr_random_deviate_value (int neg, unsigned long n,
-                           mpfr_random_deviate_t x, mpfr_t z,
+                           mpfr_random_deviate_ptr x, mpfr_ptr z,
                            gmp_randstate_t r, mpfr_rnd_t rnd)
 {
   /* r is used to add as many bits as necessary to match the precision of z */
diff --git a/src/random_deviate.h b/src/random_deviate.h
index 50da68b93..e3091f305 100644
--- a/src/random_deviate.h
+++ b/src/random_deviate.h
@@ -76,7 +76,7 @@ __MPFR_DECLSPEC int
 /* set mpfr_t z = (neg ? -1 : 1) * (n + x) */
 __MPFR_DECLSPEC int
   mpfr_random_deviate_value (int, unsigned long,
-                             mpfr_random_deviate_ptr, mpfr_t,
+                             mpfr_random_deviate_ptr, mpfr_ptr,
                              gmp_randstate_t, mpfr_rnd_t);
 
 #if defined(__cplusplus)
diff --git a/src/rndna.c b/src/rndna.c
index 34f3785c7..3ffc4d0f0 100644
--- a/src/rndna.c
+++ b/src/rndna.c
@@ -61,7 +61,7 @@ typedef enum {
    and prepares rop to give it one more bit of precision
    and to save its old value within it. */
 void
-mpfr_round_nearest_away_begin (mpfr_t rop)
+mpfr_round_nearest_away_begin (mpfr_ptr rop)
 {
   mpfr_t tmp;
   mp_size_t xsize;
@@ -129,7 +129,7 @@ mpfr_round_nearest_away_begin (mpfr_t rop)
    copying it back the result of the applied function
    and performing additional roundings. */
 int
-mpfr_round_nearest_away_end (mpfr_t rop, int inex)
+mpfr_round_nearest_away_end (mpfr_ptr rop, int inex)
 {
   mpfr_t    tmp;
   mp_size_t xsize;
diff --git a/src/set_sj.c b/src/set_sj.c
index 3403e6041..7abd60c0d 100644
--- a/src/set_sj.c
+++ b/src/set_sj.c
@@ -26,13 +26,13 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 #ifdef _MPFR_H_HAVE_INTMAX_T
 
 int
-mpfr_set_sj (mpfr_t x, intmax_t j, mpfr_rnd_t rnd)
+mpfr_set_sj (mpfr_ptr x, intmax_t j, mpfr_rnd_t rnd)
 {
   return mpfr_set_sj_2exp (x, j, 0, rnd);
 }
 
 int
-mpfr_set_sj_2exp (mpfr_t x, intmax_t j, intmax_t e, mpfr_rnd_t rnd)
+mpfr_set_sj_2exp (mpfr_ptr x, intmax_t j, intmax_t e, mpfr_rnd_t rnd)
 {
   if (j >= 0)
     return mpfr_set_uj_2exp (x, j, e, rnd);
diff --git a/src/set_str.c b/src/set_str.c
index 91d4945e3..f6b67dc32 100644
--- a/src/set_str.c
+++ b/src/set_str.c
@@ -23,7 +23,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 #include "mpfr-impl.h"
 
 int
-mpfr_set_str (mpfr_t x, const char *str, int base, mpfr_rnd_t rnd)
+mpfr_set_str (mpfr_ptr x, const char *str, int base, mpfr_rnd_t rnd)
 {
   char *p;
 
diff --git a/src/set_uj.c b/src/set_uj.c
index 558c0eea1..37ac0771b 100644
--- a/src/set_uj.c
+++ b/src/set_uj.c
@@ -29,13 +29,13 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 #define uintmaxpml (sizeof(uintmax_t) / sizeof(mp_limb_t))
 
 int
-mpfr_set_uj (mpfr_t x, uintmax_t j, mpfr_rnd_t rnd)
+mpfr_set_uj (mpfr_ptr x, uintmax_t j, mpfr_rnd_t rnd)
 {
   return mpfr_set_uj_2exp (x, j, 0, rnd);
 }
 
 int
-mpfr_set_uj_2exp (mpfr_t x, uintmax_t j, intmax_t e, mpfr_rnd_t rnd)
+mpfr_set_uj_2exp (mpfr_ptr x, uintmax_t j, intmax_t e, mpfr_rnd_t rnd)
 {
   int cnt, inex;
   mp_size_t i, k;
diff --git a/src/sin_cos.c b/src/sin_cos.c
index 90e9addfe..d4a28e10e 100644
--- a/src/sin_cos.c
+++ b/src/sin_cos.c
@@ -463,7 +463,7 @@ sin_bs_aux (mpz_t Q0, mpz_t S0, mpz_t C0, mpz_srcptr p, mpfr_prec_t r,
    Return err such that the relative error is bounded by 2^err ulps.
 */
 static int
-sincos_aux (mpfr_t s, mpfr_t c, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
+sincos_aux (mpfr_ptr s, mpfr_ptr c, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
 {
   mpfr_prec_t prec_s, sh;
   mpz_t Q, S, C, Q2, S2, C2, y;
@@ -577,7 +577,7 @@ sincos_aux (mpfr_t s, mpfr_t c, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
    Assumes s differs from c.
  */
 int
-mpfr_sincos_fast (mpfr_t s, mpfr_t c, mpfr_srcptr x, mpfr_rnd_t rnd)
+mpfr_sincos_fast (mpfr_ptr s, mpfr_ptr c, mpfr_srcptr x, mpfr_rnd_t rnd)
 {
   int inexs, inexc;
   mpfr_t x_red, ts, tc;
diff --git a/src/strtofr.c b/src/strtofr.c
index dd5a48329..de67aa741 100644
--- a/src/strtofr.c
+++ b/src/strtofr.c
@@ -226,7 +226,7 @@ fast_casecmp (const char *s1, const char *s2)
    BUT if it returns 0 (NAN or INF), the ternary value is also '0'
    (ie NAN and INF are exact) */
 static int
-parse_string (mpfr_t x, struct parsed_string *pstr,
+parse_string (mpfr_ptr x, struct parsed_string *pstr,
               const char **string, int base)
 {
   const char *str = *string;
@@ -451,7 +451,7 @@ parse_string (mpfr_t x, struct parsed_string *pstr,
    and the precision of x.
    Returns the ternary value. */
 static int
-parsed_string_to_mpfr (mpfr_t x, struct parsed_string *pstr, mpfr_rnd_t rnd)
+parsed_string_to_mpfr (mpfr_ptr x, struct parsed_string *pstr, mpfr_rnd_t rnd)
 {
   mpfr_prec_t precx, prec, ysize_bits, pstr_size;
   mpfr_exp_t exp;
@@ -935,7 +935,7 @@ free_parsed_string (struct parsed_string *pstr)
 }
 
 int
-mpfr_strtofr (mpfr_t x, const char *string, char **end, int base,
+mpfr_strtofr (mpfr_ptr x, const char *string, char **end, int base,
               mpfr_rnd_t rnd)
 {
   int res;
diff --git a/src/vasprintf.c b/src/vasprintf.c
index bb40475c1..fca6804d4 100644
--- a/src/vasprintf.c
+++ b/src/vasprintf.c
@@ -963,7 +963,7 @@ floor_log10 (mpfr_srcptr x)
 #define NDIGITS 8
 
 MPFR_RETURNS_NONNULL static char *
-mpfr_get_str_wrapper (mpfr_exp_t *exp, int base, size_t n, const mpfr_t op,
+mpfr_get_str_wrapper (mpfr_exp_t *exp, int base, size_t n, mpfr_srcptr op,
                       const struct printf_spec spec)
 {
   size_t ndigits;
diff --git a/src/zeta.c b/src/zeta.c
index f4f0ccec5..d75e55adf 100644
--- a/src/zeta.c
+++ b/src/zeta.c
@@ -35,7 +35,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
    sum(tc[i]*product((s+2j)*(s+2j-1)/n^2,j=1..i-1), i=1..p)*s*n^(-s-1)
 */
 static void
-mpfr_zeta_part_b (mpfr_t b, mpfr_srcptr s, int n, int p, mpfr_t *tc)
+mpfr_zeta_part_b (mpfr_ptr b, mpfr_srcptr s, int n, int p, mpfr_t *tc)
 {
   mpfr_t s1, d, u;
   unsigned long n2;
@@ -130,7 +130,7 @@ mpfr_zeta_c (int p, mpfr_t *tc)
           n - an integer
    Output: sum - a floating-point number approximating sum(1/i^s, i=1..n-1) */
 static void
-mpfr_zeta_part_a (mpfr_t sum, mpfr_srcptr s, int n)
+mpfr_zeta_part_a (mpfr_ptr sum, mpfr_srcptr s, int n)
 {
   mpfr_t u, s1;
   int i;
@@ -158,7 +158,7 @@ mpfr_zeta_part_a (mpfr_t sum, mpfr_srcptr s, int n)
    Output: z - Zeta(s) rounded to the precision of z with direction rnd_mode
 */
 static int
-mpfr_zeta_pos (mpfr_t z, mpfr_srcptr s, mpfr_rnd_t rnd_mode)
+mpfr_zeta_pos (mpfr_ptr z, mpfr_srcptr s, mpfr_rnd_t rnd_mode)
 {
   mpfr_t b, c, z_pre, f, s1;
   double beta, sd, dnep;
@@ -356,8 +356,8 @@ compute_add (mpfr_srcptr s, mpfr_prec_t precz)
    At input, p is Pi rounded down.
    The comments in the code are for rnd = RNDD. */
 static void
-mpfr_reflection_overflow (mpfr_t z, mpfr_t s1, const mpfr_t s, mpfr_t y,
-                          mpfr_t p, mpfr_rnd_t rnd)
+mpfr_reflection_overflow (mpfr_ptr z, mpfr_ptr s1, mpfr_srcptr s, mpfr_ptr y,
+                          mpfr_ptr p, mpfr_rnd_t rnd)
 {
   mpz_t sint;
 
@@ -432,7 +432,7 @@ mpfr_reflection_overflow (mpfr_t z, mpfr_t s1, const mpfr_t s, mpfr_t y,
 }
 
 int
-mpfr_zeta (mpfr_t z, mpfr_srcptr s, mpfr_rnd_t rnd_mode)
+mpfr_zeta (mpfr_ptr z, mpfr_srcptr s, mpfr_rnd_t rnd_mode)
 {
   mpfr_t z_pre, s1, y, p;
   long add;
diff --git a/tests/tcmp2.c b/tests/tcmp2.c
index a0c8e3272..811645d6b 100644
--- a/tests/tcmp2.c
+++ b/tests/tcmp2.c
@@ -24,7 +24,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 
 /* set bit n of x to b, where bit 0 is the most significant one */
 static void
-set_bit (mpfr_t x, unsigned int n, int b)
+set_bit (mpfr_ptr x, unsigned int n, int b)
 {
   unsigned l;
   mp_size_t xn;
diff --git a/tests/tdiv.c b/tests/tdiv.c
index 6ef313014..1e99e64af 100644
--- a/tests/tdiv.c
+++ b/tests/tdiv.c
@@ -369,7 +369,7 @@ check_convergence (void)
 /* given y = o(x/u), x, u, find the inexact flag by
    multiplying y by u */
 static int
-get_inexact (mpfr_t y, mpfr_t x, mpfr_t u)
+get_inexact (mpfr_ptr y, mpfr_ptr x, mpfr_ptr u)
 {
   mpfr_t xx;
   int inex;
diff --git a/tests/teq.c b/tests/teq.c
index 0eab5afed..f2b8cafa5 100644
--- a/tests/teq.c
+++ b/tests/teq.c
@@ -23,7 +23,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 #include "mpfr-test.h"
 
 static void
-teq (mpfr_t x)
+teq (mpfr_ptr x)
 {
   mpfr_t y;
   unsigned long k, px, mx;
diff --git a/tests/terandom_chisq.c b/tests/terandom_chisq.c
index 2b14c345d..c6c7a05fd 100644
--- a/tests/terandom_chisq.c
+++ b/tests/terandom_chisq.c
@@ -26,7 +26,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
  * exponential distribution.  We only take differences of this function so the
  * offset doesn't matter; here Phi(0) = 0. */
 static void
-exponential_cumulative (mpfr_t z, mpfr_t x, mpfr_rnd_t rnd)
+exponential_cumulative (mpfr_ptr z, mpfr_ptr x, mpfr_rnd_t rnd)
 {
   mpfr_neg (z, x, rnd);
   mpfr_expm1 (z, z, rnd);
@@ -43,7 +43,7 @@ exponential_cumulative (mpfr_t z, mpfr_t x, mpfr_rnd_t rnd)
  * TAOCP, Vol 2, 3.3.1, Table 1.  It more accurate than the similar formula,
  * DLMF 8.11.10. */
 static void
-chisq_prob (mpfr_t q, long nu, mpfr_t chisqp)
+chisq_prob (mpfr_ptr q, long nu, mpfr_ptr chisqp)
 {
   mpfr_t t;
   mpfr_rnd_t rnd;
@@ -170,7 +170,7 @@ test_erandom_chisq_cont (long num, mpfr_prec_t prec, int nu,
  * this function.  low precision means prec = 2, 3, or 4.  High values of
  * precision will result in integer overflow. */
 static long
-sequential (mpfr_t x)
+sequential (mpfr_ptr x)
 {
   long expt, prec;
 
diff --git a/tests/tfmma.c b/tests/tfmma.c
index 38de6c5f6..bd8e8756b 100644
--- a/tests/tfmma.c
+++ b/tests/tfmma.c
@@ -24,7 +24,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 
 /* check both mpfr_fmma and mpfr_fmms */
 static void
-random_test (mpfr_t a, mpfr_t b, mpfr_t c, mpfr_t d, mpfr_rnd_t rnd)
+random_test (mpfr_ptr a, mpfr_ptr b, mpfr_ptr c, mpfr_ptr d, mpfr_rnd_t rnd)
 {
   mpfr_t ref, res, ab, cd;
   int inex_ref, inex_res;
diff --git a/tests/tfmod.c b/tests/tfmod.c
index 42e09b504..372ca82c8 100644
--- a/tests/tfmod.c
+++ b/tests/tfmod.c
@@ -62,8 +62,8 @@ slow_fmod (mpfr_ptr r, mpfr_srcptr x, mpfr_srcptr y, mpfr_rnd_t rnd)
 }
 
 static void
-test_failed (mpfr_t erem, mpfr_t grem, int eret, int gret, mpfr_t x, mpfr_t y,
-             mpfr_rnd_t rnd)
+test_failed (mpfr_ptr erem, mpfr_ptr grem, int eret, int gret,
+             mpfr_ptr x, mpfr_ptr y, mpfr_rnd_t rnd)
 {
   printf ("error: mpfr_fmod (r, x, y, rnd)\n  x = ");
   mpfr_out_str (stdout, 10, 0, x, MPFR_RNDD);
@@ -83,7 +83,7 @@ test_failed (mpfr_t erem, mpfr_t grem, int eret, int gret, mpfr_t x, mpfr_t y,
 }
 
 static void
-check (mpfr_t r0, mpfr_t x, mpfr_t y, mpfr_rnd_t rnd)
+check (mpfr_ptr r0, mpfr_ptr x, mpfr_ptr y, mpfr_rnd_t rnd)
 {
   int inex0, inex1;
   mpfr_t r1;
diff --git a/tests/tfprintf.c b/tests/tfprintf.c
index 63b762c5b..7b11f0cb7 100644
--- a/tests/tfprintf.c
+++ b/tests/tfprintf.c
@@ -65,7 +65,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 const int prec_max_printf = 5000;
 
 static void
-check (FILE *fout, const char *fmt, mpfr_t x)
+check (FILE *fout, const char *fmt, mpfr_ptr x)
 {
   if (mpfr_fprintf (fout, fmt, x) == -1)
     {
diff --git a/tests/tgamma.c b/tests/tgamma.c
index ca13066f6..d151878af 100644
--- a/tests/tgamma.c
+++ b/tests/tgamma.c
@@ -890,7 +890,7 @@ tiny (int stop)
    computing with a working precision p2. Assume that x is not an
    integer <= 2. */
 static void
-exp_lgamma (mpfr_t x, mpfr_prec_t p1, mpfr_prec_t p2)
+exp_lgamma (mpfr_ptr x, mpfr_prec_t p1, mpfr_prec_t p2)
 {
   mpfr_t yd, yu, zd, zu;
   int inexd, inexu, sign;
diff --git a/tests/tnrandom_chisq.c b/tests/tnrandom_chisq.c
index 3eaabf83a..4a41a78eb 100644
--- a/tests/tnrandom_chisq.c
+++ b/tests/tnrandom_chisq.c
@@ -26,7 +26,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
  * for the normal distribution.  We only take differences of this function so
  * the offset doesn't matter; here Phi(0) = 0. */
 static void
-normal_cumulative (mpfr_t z, mpfr_t x, mpfr_rnd_t rnd)
+normal_cumulative (mpfr_ptr z, mpfr_ptr x, mpfr_rnd_t rnd)
 {
   mpfr_sqrt_ui (z, 2, rnd);
   mpfr_div (z, x, z, rnd);
@@ -44,7 +44,7 @@ normal_cumulative (mpfr_t z, mpfr_t x, mpfr_rnd_t rnd)
  * TAOCP, Vol 2, 3.3.1, Table 1.  It more accurate than the similar formula,
  * DLMF 8.11.10. */
 static void
-chisq_prob (mpfr_t q, long nu, mpfr_t chisqp)
+chisq_prob (mpfr_ptr q, long nu, mpfr_ptr chisqp)
 {
   mpfr_t t;
   mpfr_rnd_t rnd;
@@ -166,7 +166,7 @@ test_nrandom_chisq_cont (long num, mpfr_prec_t prec, int nu,
  * this function.  low precision means prec = 2, 3, or 4.  High values of
  * precision will result in integer overflow. */
 static long
-sequential (mpfr_t x)
+sequential (mpfr_ptr x)
 {
   long expt, prec;
 
diff --git a/tests/tprintf.c b/tests/tprintf.c
index 681319181..8a7110044 100644
--- a/tests/tprintf.c
+++ b/tests/tprintf.c
@@ -74,7 +74,7 @@ const int prec_max_printf = 5000;
 int stdout_redirect;
 
 static void
-check (const char *fmt, mpfr_t x)
+check (const char *fmt, mpfr_ptr x)
 {
   if (mpfr_printf (fmt, x) == -1)
     {
diff --git a/tests/trint.c b/tests/trint.c
index 1d4dffb0e..3cf868816 100644
--- a/tests/trint.c
+++ b/tests/trint.c
@@ -367,7 +367,7 @@ test_against_libc (void)
 #endif
 
 static void
-err (const char *str, mp_size_t s, mpfr_t x, mpfr_t y, mpfr_prec_t p,
+err (const char *str, mp_size_t s, mpfr_ptr x, mpfr_ptr y, mpfr_prec_t p,
      mpfr_rnd_t r, int trint, int inexact)
 {
   printf ("Error: %s\ns = %u, p = %u, r = %s, trint = %d, inexact = %d\nx = ",
diff --git a/tests/tsinh_cosh.c b/tests/tsinh_cosh.c
index 8911bde3e..59d7128bb 100644
--- a/tests/tsinh_cosh.c
+++ b/tests/tsinh_cosh.c
@@ -23,7 +23,7 @@ https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
 #include "mpfr-test.h"
 
 static void
-failed (mpfr_t x, mpfr_t esh, mpfr_t gsh, mpfr_t ech, mpfr_t gch)
+failed (mpfr_ptr x, mpfr_ptr esh, mpfr_ptr gsh, mpfr_ptr ech, mpfr_ptr gch)
 {
   printf ("error : mpfr_sinh_cosh (x) x = ");
   mpfr_out_str (stdout, 10, 0, x, MPFR_RNDD);
@@ -43,7 +43,7 @@ failed (mpfr_t x, mpfr_t esh, mpfr_t gsh, mpfr_t ech, mpfr_t gch)
 
 /* check against sinh, cosh */
 static void
-check (mpfr_t x, mpfr_rnd_t rnd)
+check (mpfr_ptr x, mpfr_rnd_t rnd)
 {
   mpfr_t s, c, sx, cx;
   int isc, is, ic;
diff --git a/tests/tsqr.c b/tests/tsqr.c
index 6ee8d63c4..5b2da023a 100644
--- a/tests/tsqr.c
+++ b/tests/tsqr.c
@@ -33,7 +33,7 @@ inexact_sign (int x)
 
 static void
 error1 (mpfr_rnd_t rnd, mpfr_prec_t prec,
-        mpfr_t in, mpfr_t outmul, mpfr_t outsqr)
+        mpfr_t in, mpfr_ptr outmul, mpfr_ptr outsqr)
 {
   printf("ERROR: for %s and prec=%lu\nINPUT=", mpfr_print_rnd_mode(rnd),
          (unsigned long) prec);
@@ -44,7 +44,7 @@ error1 (mpfr_rnd_t rnd, mpfr_prec_t prec,
 }
 
 static void
-error2 (mpfr_rnd_t rnd, mpfr_prec_t prec, mpfr_t in, mpfr_t out,
+error2 (mpfr_rnd_t rnd, mpfr_prec_t prec, mpfr_ptr in, mpfr_ptr out,
         int inexactmul, int inexactsqr)
 {
   printf("ERROR: for %s and prec=%lu\nINPUT=", mpfr_print_rnd_mode(rnd),
diff --git a/tests/tsum.c b/tests/tsum.c
index 6a0f02720..6a0714d14 100644
--- a/tests/tsum.c
+++ b/tests/tsum.c
@@ -59,7 +59,7 @@ get_prec_max (mpfr_t *t, int n)
 }
 
 static void
-get_exact_sum (mpfr_t sum, mpfr_t *tab, int n)
+get_exact_sum (mpfr_ptr sum, mpfr_t *tab, int n)
 {
   int i;
 
@@ -1198,7 +1198,7 @@ check_coverage (void)
 }
 
 static int
-mpfr_sum_naive (mpfr_t s, mpfr_t *x, int n, mpfr_rnd_t rnd)
+mpfr_sum_naive (mpfr_ptr s, mpfr_t *x, int n, mpfr_rnd_t rnd)
 {
   int ret, i;
   switch (n)