Suppress some #define and fix symbol names (makes code cleaner):

perl -pi -e 's/__mpfr_flags/__gmpfr_flags/g' **/*.{c,h}
perl -pi -e 's/__mpfr_emin/__gmpfr_emin/g' **/*.{c,h}
perl -pi -e 's/__mpfr_emax/__gmpfr_emax/g' **/*.{c,h}
perl -pi -e 's/__mpfr_default_fp_bit_precision/__gmpfr_default_fp_bit_precision/g' **/*.{c,h}
perl -pi -e 's/__gmp_default_rounding_mode/__gmpfr_default_rounding_mode/g' **/*.{c,h}
perl -pi -e 's/__mpfr_const_log2_prec/__gmpfr_const_log2_prec/g' **/*.{c,h}
perl -pi -e 's/__mpfr_const_pi_prec/__gmpfr_const_pi_prec/g' **/*.{c,h}
perl -pi -e 's/_mpfr_ceil_log2/__gmpfr_ceil_log2/g' **/*.{c,h}
perl -pi -e 's/_mpfr_floor_log2/__gmpfr_floor_log2/g' **/*.{c,h}
perl -pi -e 's/_mpfr_ceil_exp2/__gmpfr_ceil_exp2/g' **/*.{c,h}
perl -pi -e 's/_mpfr_isqrt/__gmpfr_isqrt/g' **/*.{c,h}
perl -pi -e 's/_mpfr_cuberoot/__gmpfr_cuberoot/g' **/*.{c,h}
perl -pi -e 's/^#define __gmpfr_.*\n//' *.h


git-svn-id: svn://scm.gforge.inria.fr/svn/mpfr/trunk@2125 280ebfd0-de03-0410-8827-d642c229c3f4

69 files changed, 253 insertions, 265 deletions

diff --git a/acos.c b/acos.c
index ba1d16f41..f5a88931e 100644
--- a/acos.c
+++ b/acos.c
@@ -116,7 +116,7 @@ mpfr_acos (mpfr_ptr acos, mpfr_srcptr x, mp_rnd_t rnd_mode)
           good = 1;
         }
       else
-        realprec += _mpfr_ceil_log2 ((double) realprec);
+        realprec += __gmpfr_ceil_log2 ((double) realprec);
 
     mpfr_clear (tmp);
     mpfr_clear (arcc);
diff --git a/acosh.c b/acosh.c
index e8f5ad636..5f0c8476e 100644
--- a/acosh.c
+++ b/acosh.c
@@ -75,7 +75,7 @@ mpfr_acosh (mpfr_ptr y, mpfr_srcptr x , mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt = MAX(Nx, Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt = Nt + 4 + _mpfr_ceil_log2 (Nt);
+    Nt = Nt + 4 + __gmpfr_ceil_log2 (Nt);
 
     /* initialization of intermediary variables */
     mpfr_init (t);
diff --git a/add1.c b/add1.c
index b28d1152d..35c603d08 100644
--- a/add1.c
+++ b/add1.c
@@ -160,7 +160,7 @@ mpfr_add1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c,
       if (cc) /* carry */
         {
           mp_exp_t exp = MPFR_EXP(a);
-          if (exp == __mpfr_emax)
+          if (exp == __gmpfr_emax)
             {
               inex = mpfr_set_overflow(a, rnd_mode, MPFR_SIGN(a));
               goto end_of_add;
@@ -302,7 +302,7 @@ mpfr_add1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c,
                   && mpn_add_1(ap, ap, an, MP_LIMB_T_ONE << sh))
                 {
                   mp_exp_t exp = MPFR_EXP(a);
-                  if (exp == __mpfr_emax)
+                  if (exp == __gmpfr_emax)
                     {
                       inex = mpfr_set_overflow(a, rnd_mode, MPFR_SIGN(a));
                       goto end_of_add;
@@ -356,7 +356,7 @@ mpfr_add1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c,
                   if (rb == 0 && mpn_add_1(ap, ap, an, MP_LIMB_T_ONE << sh))
                     {
                       mp_exp_t exp = MPFR_EXP(a);
-                      if (exp == __mpfr_emax)
+                      if (exp == __gmpfr_emax)
                         {
                           inex = mpfr_set_overflow(a, rnd_mode, MPFR_SIGN(a));
                           goto end_of_add;
@@ -533,7 +533,7 @@ mpfr_add1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c,
   if (mpn_add_1(ap, ap, an, MP_LIMB_T_ONE << sh))
     {
       mp_exp_t exp = MPFR_EXP(a);
-      if (exp == __mpfr_emax)
+      if (exp == __gmpfr_emax)
         inex = mpfr_set_overflow(a, rnd_mode, MPFR_SIGN(a));
       else
         {
diff --git a/add_one_ulp.c b/add_one_ulp.c
index a9a6cc9f5..b831c254f 100644
--- a/add_one_ulp.c
+++ b/add_one_ulp.c
@@ -44,7 +44,7 @@ mpfr_add_one_ulp (mpfr_ptr x, mp_rnd_t rnd_mode)
   if (mpn_add_1 (xp, xp, xn, MP_LIMB_T_ONE << sh)) /* got 1.0000... */
     {
       mp_exp_t exp = MPFR_EXP(x);
-      if (exp == __mpfr_emax)
+      if (exp == __gmpfr_emax)
         return mpfr_set_overflow(x, rnd_mode, MPFR_SIGN(x));
       else
         {
diff --git a/agm.c b/agm.c
index 343a16bec..9bfde443c 100644
--- a/agm.c
+++ b/agm.c
@@ -38,7 +38,7 @@ mpfr_agm (mpfr_ptr r, mpfr_srcptr op2, mpfr_srcptr op1, mp_rnd_t rnd_mode)
   if (MPFR_IS_NAN(op1) || MPFR_IS_NAN(op2))
     {
       MPFR_SET_NAN(r);
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       MPFR_RET_NAN;
     }
 
@@ -46,7 +46,7 @@ mpfr_agm (mpfr_ptr r, mpfr_srcptr op2, mpfr_srcptr op1, mp_rnd_t rnd_mode)
   if ((MPFR_SIGN(op1) < 0) || (MPFR_SIGN(op2) < 0))
     {
       MPFR_SET_NAN(r);
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       MPFR_RET_NAN;
     }
 
@@ -118,13 +118,13 @@ mpfr_agm (mpfr_ptr r, mpfr_srcptr op2, mpfr_srcptr op1, mp_rnd_t rnd_mode)
     int err, can_round;
     mp_prec_t eq;
     
-    err=1 + (int) ((3.0/2.0*(double)_mpfr_ceil_log2((double)p)+1.0)*_mpfr_ceil_exp2(-(double)p)
-	     +3.0*_mpfr_ceil_exp2(-2.0*(double)p*uo/(vo-uo)));
+    err=1 + (int) ((3.0/2.0*(double)__gmpfr_ceil_log2((double)p)+1.0)*__gmpfr_ceil_exp2(-(double)p)
+	     +3.0*__gmpfr_ceil_exp2(-2.0*(double)p*uo/(vo-uo)));
     if(p-err-3<=q) {
       p=q+err+4;
       err= 1 + 
-	(int) ((3.0/2.0*_mpfr_ceil_log2((double)p)+1.0)*_mpfr_ceil_exp2(-(double)p)
-	       +3.0*_mpfr_ceil_exp2(-2.0*(double)p*uo/(vo-uo)));
+	(int) ((3.0/2.0*__gmpfr_ceil_log2((double)p)+1.0)*__gmpfr_ceil_exp2(-(double)p)
+	       +3.0*__gmpfr_ceil_exp2(-2.0*(double)p*uo/(vo-uo)));
     }
 
     /* Calculus of un and vn */
diff --git a/asin.c b/asin.c
index a43560678..f124b6447 100644
--- a/asin.c
+++ b/asin.c
@@ -162,7 +162,7 @@ mpfr_asin (mpfr_ptr asin, mpfr_srcptr x, mp_rnd_t rnd_mode)
 	}
       else
 	{
-	  realprec += _mpfr_ceil_log2 ((double) realprec);
+	  realprec += __gmpfr_ceil_log2 ((double) realprec);
 #ifdef DEBUG
 	  printf("RETRY\n");
 #endif
diff --git a/asinh.c b/asinh.c
index f5cf98d8b..8ca8f41d7 100644
--- a/asinh.c
+++ b/asinh.c
@@ -72,7 +72,7 @@ mpfr_asinh (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
   Nt = MAX(Nx, Ny);
 
   /* the optimal number of bits : see algorithms.ps */
-  Nt = Nt + 4 + _mpfr_ceil_log2 (Nt);
+  Nt = Nt + 4 + __gmpfr_ceil_log2 (Nt);
 
   /* initialize intermediary variables */
   mpfr_init2 (t, 2);
diff --git a/atan.c b/atan.c
index f82b117e4..73f34336c 100644
--- a/atan.c
+++ b/atan.c
@@ -140,17 +140,17 @@ mpfr_atan (mpfr_ptr arctangent, mpfr_srcptr x, mp_rnd_t rnd_mode)
   else
       suplement = 2-MPFR_EXP(xp);
 
-  prec_x = _mpfr_ceil_log2 ((double) MPFR_PREC(x) / BITS_PER_MP_LIMB);
-  logn = _mpfr_ceil_log2 ((double) prec_x);
+  prec_x = __gmpfr_ceil_log2 ((double) MPFR_PREC(x) / BITS_PER_MP_LIMB);
+  logn = __gmpfr_ceil_log2 ((double) prec_x);
   if (logn < 2) logn = 2;
-  realprec = prec_arctan + _mpfr_ceil_log2((double) prec_arctan) + 4;
+  realprec = prec_arctan + __gmpfr_ceil_log2((double) prec_arctan) + 4;
   mpz_init(ukz);
   mpz_init(square);
 
 
   while (!good){
-    N0 = _mpfr_ceil_log2((double) realprec + suplement + CST);
-    estimated_delta = 1 + suplement + _mpfr_ceil_log2((double) (3*N0-2));
+    N0 = __gmpfr_ceil_log2((double) realprec + suplement + CST);
+    estimated_delta = 1 + suplement + __gmpfr_ceil_log2((double) (3*N0-2));
     Prec = realprec+estimated_delta;
 
     /* Initialisation    */
@@ -236,7 +236,7 @@ mpfr_atan (mpfr_ptr arctangent, mpfr_srcptr x, mp_rnd_t rnd_mode)
       }
     else
       {
-	realprec += _mpfr_ceil_log2 ((double) realprec);
+	realprec += __gmpfr_ceil_log2 ((double) realprec);
       }
 
     mpfr_clear(sk);
diff --git a/atanh.c b/atanh.c
index c56b65e8f..9623c1c78 100644
--- a/atanh.c
+++ b/atanh.c
@@ -92,7 +92,7 @@ mpfr_atanh (mpfr_ptr y, mpfr_srcptr xt , mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt=MAX(Nx,Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt=Nt+4+_mpfr_ceil_log2(Nt);
+    Nt=Nt+4+__gmpfr_ceil_log2(Nt);
 
     /* initialise of intermediary	variable */
     mpfr_init(t);             
@@ -115,7 +115,7 @@ mpfr_atanh (mpfr_ptr y, mpfr_srcptr xt , mp_rnd_t rnd_mode)
       mpfr_div_2ui(t,te,1,GMP_RNDN);  /* (1/2)*ln((1+xt)/(1-xt))*/
 	
       /* estimation of the error see- algorithms.ps*/
-      /* err=Nt-_mpfr_ceil_log2(1+5*pow(2,1-MPFR_EXP(t)));*/
+      /* err=Nt-__gmpfr_ceil_log2(1+5*pow(2,1-MPFR_EXP(t)));*/
       err=Nt-(MAX(4-MPFR_EXP(t),0)+1);
 
       /* actualisation of the precision */
diff --git a/const_euler.c b/const_euler.c
index 91e55c8b3..0334f328b 100644
--- a/const_euler.c
+++ b/const_euler.c
@@ -37,7 +37,7 @@ mpfr_const_euler (mpfr_t x, mp_rnd_t rnd)
   mpfr_t y, z;
   unsigned long n;
 
-  log2m = _mpfr_ceil_log2 ((double) prec);
+  log2m = __gmpfr_ceil_log2 ((double) prec);
   m = prec + log2m;
 
   mpfr_init (y);
@@ -83,7 +83,7 @@ mpfr_const_euler_S (mpfr_t x, unsigned long n)
   N = (long) (ALPHA * (double) n + 1.0); /* ceil(alpha * n) */
 
   m = MPFR_PREC(x) + (unsigned long) ((double) n / LOG2)
-    + _mpfr_ceil_log2 ((double) N) + 1;
+    + __gmpfr_ceil_log2 ((double) N) + 1;
 
   mpz_init_set_ui (a, 1);
   mpz_mul_2exp (a, a, m); /* a=-2^m where m is the precision of x */
diff --git a/const_log2.c b/const_log2.c
index fbeabd44b..df7f29e59 100644
--- a/const_log2.c
+++ b/const_log2.c
@@ -27,7 +27,7 @@ MA 02111-1307, USA. */
 #include "mpfr-impl.h"
 
 mpfr_t __mpfr_const_log2; /* stored value of log(2) */
-mp_prec_t __mpfr_const_log2_prec = 0; /* precision of stored value */
+mp_prec_t __gmpfr_const_log2_prec = 0; /* precision of stored value */
 static mp_rnd_t __mpfr_const_log2_rnd; /* rounding mode of stored value */
 
 static int mpfr_aux_log2 _PROTO ((mpfr_ptr, mpz_srcptr, int, int));
@@ -65,10 +65,10 @@ mpfr_const_aux_log2 (mpfr_ptr mylog, mp_rnd_t rnd_mode)
   mp_prec_t prec_x;
 
   mpz_init(cst);
-  logn =  _mpfr_ceil_log2 ((double) MPFR_PREC(mylog));
+  logn =  __gmpfr_ceil_log2 ((double) MPFR_PREC(mylog));
   prec_x = prec_i_want + logn;
   while (!good){
-    prec = _mpfr_ceil_log2 ((double) prec_x);
+    prec = __gmpfr_ceil_log2 ((double) prec_x);
     mpfr_init2(tmp1, prec_x);
     mpfr_init2(result, prec_x);
     mpfr_init2(tmp2, prec_x);
@@ -134,10 +134,10 @@ mpfr_const_log2 (mpfr_ptr x, mp_rnd_t rnd_mode)
   MPFR_CLEAR_FLAGS(x); 
 
   /* has stored value enough precision ? */
-  if (precx <= __mpfr_const_log2_prec)
+  if (precx <= __gmpfr_const_log2_prec)
     {
       if ((rnd_mode == __mpfr_const_log2_rnd) ||
-          mpfr_can_round (__mpfr_const_log2, __mpfr_const_log2_prec - 1,
+          mpfr_can_round (__mpfr_const_log2, __gmpfr_const_log2_prec - 1,
                           __mpfr_const_log2_rnd, rnd_mode, precx))
         {
           mpfr_set (x, __mpfr_const_log2, rnd_mode);
@@ -150,7 +150,7 @@ mpfr_const_log2 (mpfr_ptr x, mp_rnd_t rnd_mode)
     {
       /* the following was checked by exhaustive search to give a correct
          result for all 4 rounding modes up to precx = 13500 */
-      N = precx + 2 * _mpfr_ceil_log2 ((double) precx) + 1;
+      N = precx + 2 * __gmpfr_ceil_log2 ((double) precx) + 1;
 
       mpz_init (s); /* set to zero */
       mpz_init (u);
@@ -176,12 +176,12 @@ mpfr_const_log2 (mpfr_ptr x, mp_rnd_t rnd_mode)
     mpfr_const_aux_log2(x, rnd_mode);
 
   /* store computed value */
-  if (__mpfr_const_log2_prec == 0)
+  if (__gmpfr_const_log2_prec == 0)
     mpfr_init2 (__mpfr_const_log2, precx);
   else
     mpfr_set_prec (__mpfr_const_log2, precx);
 
   mpfr_set (__mpfr_const_log2, x, rnd_mode);
-  __mpfr_const_log2_prec = precx;
+  __gmpfr_const_log2_prec = precx;
   __mpfr_const_log2_rnd = rnd_mode;
 }
diff --git a/const_pi.c b/const_pi.c
index 440594edc..faad71abf 100644
--- a/const_pi.c
+++ b/const_pi.c
@@ -53,11 +53,11 @@ mpfr_pi_machin3 (mpfr_ptr mylog, mp_rnd_t rnd_mode)
   mpz_t cst;
 
   MPFR_CLEAR_FLAGS(mylog); 
-  logn =  _mpfr_ceil_log2 ((double) MPFR_PREC(mylog));
+  logn =  __gmpfr_ceil_log2 ((double) MPFR_PREC(mylog));
   prec_x = prec_i_want + logn + 5;
   mpz_init(cst);  
   while (!good){
-  prec = _mpfr_ceil_log2 ((double) prec_x);
+  prec = __gmpfr_ceil_log2 ((double) prec_x);
 
   mpfr_init2(tmp1, prec_x);
   mpfr_init2(tmp2, prec_x);
@@ -149,7 +149,7 @@ so Pi*16^N-S'(N) <= N+1 (as 1/4/N^2 < 1)
 */
 
 mpfr_t __mpfr_const_pi; /* stored value of Pi */
-mp_prec_t __mpfr_const_pi_prec = 0; /* precision of stored value */
+mp_prec_t __gmpfr_const_pi_prec = 0; /* precision of stored value */
 static mp_rnd_t __mpfr_const_pi_rnd; /* rounding mode of stored value */
 
 void 
@@ -160,9 +160,9 @@ mpfr_const_pi (mpfr_ptr x, mp_rnd_t rnd_mode)
   prec=MPFR_PREC(x);
 
   /* has stored value enough precision ? */
-  if ((prec==__mpfr_const_pi_prec && rnd_mode==__mpfr_const_pi_rnd) ||
-      (prec<=__mpfr_const_pi_prec &&
-      mpfr_can_round(__mpfr_const_pi, __mpfr_const_pi_prec, 
+  if ((prec==__gmpfr_const_pi_prec && rnd_mode==__mpfr_const_pi_rnd) ||
+      (prec<=__gmpfr_const_pi_prec &&
+      mpfr_can_round(__mpfr_const_pi, __gmpfr_const_pi_prec, 
 		     __mpfr_const_pi_rnd, rnd_mode, prec)))
     {
       mpfr_set(x, __mpfr_const_pi, rnd_mode); return; 
@@ -173,7 +173,7 @@ mpfr_const_pi (mpfr_ptr x, mp_rnd_t rnd_mode)
     N=1; 
     do {
       oldN = N;
-      N = (prec+3)/4 + _mpfr_ceil_log2((double) N + 1.0);
+      N = (prec+3)/4 + __gmpfr_ceil_log2((double) N + 1.0);
     } while (N != oldN);
     mpz_init(pi); mpz_init(num); mpz_init(den); mpz_init(d3); mpz_init(d2);
     mpz_init(tmp);
@@ -212,9 +212,9 @@ mpfr_const_pi (mpfr_ptr x, mp_rnd_t rnd_mode)
   } else
      mpfr_pi_machin3(x, rnd_mode);
   /* store computed value */
-  if (__mpfr_const_pi_prec==0) mpfr_init2(__mpfr_const_pi, prec);
+  if (__gmpfr_const_pi_prec==0) mpfr_init2(__mpfr_const_pi, prec);
   else mpfr_set_prec(__mpfr_const_pi, prec);
   mpfr_set(__mpfr_const_pi, x, rnd_mode);
-  __mpfr_const_pi_prec=prec;
+  __gmpfr_const_pi_prec=prec;
   __mpfr_const_pi_rnd=rnd_mode;
 }
diff --git a/cos.c b/cos.c
index 2d6b392fb..0e50df88e 100644
--- a/cos.c
+++ b/cos.c
@@ -47,7 +47,7 @@ mpfr_cos (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
 
   precy = MPFR_PREC(y);
 
-  K0 = _mpfr_isqrt(precy / 2);
+  K0 = __gmpfr_isqrt(precy / 2);
   /* we need at least K + log2(precy/K) extra bits */
   m = precy + 3 * K0 + 3;
 
diff --git a/cosh.c b/cosh.c
index 8c95ea66e..98a40913d 100644
--- a/cosh.c
+++ b/cosh.c
@@ -77,7 +77,7 @@ mpfr_cosh (mpfr_ptr y, mpfr_srcptr xt , mp_rnd_t rnd_mode)
       /* compute the precision of intermediary variable */
       Nt=MAX(Nx,Ny);
       /* the optimal number of bits : see algorithms.ps */
-      Nt=Nt+3+_mpfr_ceil_log2(Nt);
+      Nt=Nt+3+__gmpfr_ceil_log2(Nt);
 
 
       /* initialise of intermediary	variable */
diff --git a/div_2si.c b/div_2si.c
index b3ea64e39..207f6e4b0 100644
--- a/div_2si.c
+++ b/div_2si.c
@@ -33,19 +33,19 @@ mpfr_div_2si (mpfr_ptr y, mpfr_srcptr x, long int n, mp_rnd_t rnd_mode)
 
   if (MPFR_IS_FP(y) && MPFR_NOTZERO(y))
     {
-      if (n > 0 && (__mpfr_emin > MPFR_EMAX_MAX - n ||
-                    MPFR_EXP(y) < __mpfr_emin + n))
+      if (n > 0 && (__gmpfr_emin > MPFR_EMAX_MAX - n ||
+                    MPFR_EXP(y) < __gmpfr_emin + n))
         {
           if (rnd_mode == GMP_RNDN &&
-              (__mpfr_emin > MPFR_EMAX_MAX - (n - 1) ||
-               MPFR_EXP(y) < __mpfr_emin + (n - 1) ||
+              (__gmpfr_emin > MPFR_EMAX_MAX - (n - 1) ||
+               MPFR_EXP(y) < __gmpfr_emin + (n - 1) ||
                mpfr_powerof2_raw (y)))
             rnd_mode = GMP_RNDZ;
           return mpfr_set_underflow (y, rnd_mode, MPFR_SIGN(y));
         }
 
-      if (n < 0 && (__mpfr_emax < MPFR_EMIN_MIN - n ||
-                    MPFR_EXP(y) > __mpfr_emax + n))
+      if (n < 0 && (__gmpfr_emax < MPFR_EMIN_MIN - n ||
+                    MPFR_EXP(y) > __gmpfr_emax + n))
         return mpfr_set_overflow (y, rnd_mode, MPFR_SIGN(y));
 
       MPFR_EXP(y) -= n;
diff --git a/div_2ui.c b/div_2ui.c
index 1cf975c8b..294ee85ab 100644
--- a/div_2ui.c
+++ b/div_2ui.c
@@ -48,12 +48,12 @@ mpfr_div_2ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int n, mp_rnd_t rnd_mode)
       /* MPFR_EMAX_MAX - (long) n is signed and doesn't lead to an integer
          overflow; the first test useful so that the real test can't lead
          to an integer overflow. */
-      if (__mpfr_emin > MPFR_EMAX_MAX - (long) n ||
-          MPFR_EXP(y) < __mpfr_emin + (long) n)
+      if (__gmpfr_emin > MPFR_EMAX_MAX - (long) n ||
+          MPFR_EXP(y) < __gmpfr_emin + (long) n)
         {
           if (rnd_mode == GMP_RNDN &&
-              (__mpfr_emin > MPFR_EMAX_MAX - (long) (n - 1) ||
-               MPFR_EXP(y) < __mpfr_emin + (long) (n - 1) ||
+              (__gmpfr_emin > MPFR_EMAX_MAX - (long) (n - 1) ||
+               MPFR_EXP(y) < __gmpfr_emin + (long) (n - 1) ||
                mpfr_powerof2_raw (y)))
             rnd_mode = GMP_RNDZ;
           return mpfr_set_underflow (y, rnd_mode, MPFR_SIGN(y));
diff --git a/exceptions.c b/exceptions.c
index ec7887308..c2bf923a7 100644
--- a/exceptions.c
+++ b/exceptions.c
@@ -24,17 +24,17 @@ MA 02111-1307, USA. */
 #include "mpfr.h"
 #include "mpfr-impl.h"
 
-unsigned int __mpfr_flags = 0;
+unsigned int __gmpfr_flags = 0;
 
-mp_exp_t __mpfr_emin = MPFR_EMIN_DEFAULT;
-mp_exp_t __mpfr_emax = MPFR_EMAX_DEFAULT;
+mp_exp_t __gmpfr_emin = MPFR_EMIN_DEFAULT;
+mp_exp_t __gmpfr_emax = MPFR_EMAX_DEFAULT;
 
 #undef mpfr_get_emin
 
 mp_exp_t
 mpfr_get_emin (void)
 {
-  return __mpfr_emin;
+  return __gmpfr_emin;
 }
 
 #undef mpfr_set_emin
@@ -44,7 +44,7 @@ mpfr_set_emin (mp_exp_t exponent)
 {
   if (exponent >= MPFR_EMIN_MIN && exponent <= MPFR_EMIN_MAX)
     {
-      __mpfr_emin = exponent;
+      __gmpfr_emin = exponent;
       return 0;
     }
   else
@@ -58,7 +58,7 @@ mpfr_set_emin (mp_exp_t exponent)
 mp_exp_t
 mpfr_get_emax (void)
 {
-  return __mpfr_emax;
+  return __gmpfr_emax;
 }
 
 #undef mpfr_set_emax
@@ -68,7 +68,7 @@ mpfr_set_emax (mp_exp_t exponent)
 {
   if (exponent >= MPFR_EMAX_MIN && exponent <= MPFR_EMAX_MAX)
     {
-      __mpfr_emax = exponent;
+      __gmpfr_emax = exponent;
       return 0;
     }
   else
@@ -82,7 +82,7 @@ mpfr_set_emax (mp_exp_t exponent)
 void
 mpfr_clear_flags (void)
 {
-  __mpfr_flags = 0;
+  __gmpfr_flags = 0;
 }
 
 #undef mpfr_clear_underflow
@@ -90,7 +90,7 @@ mpfr_clear_flags (void)
 void
 mpfr_clear_underflow (void)
 {
-  __mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW;
+  __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW;
 }
 
 #undef mpfr_clear_overflow
@@ -98,7 +98,7 @@ mpfr_clear_underflow (void)
 void
 mpfr_clear_overflow (void)
 {
-  __mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW;
+  __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW;
 }
 
 #undef mpfr_clear_nanflag
@@ -106,7 +106,7 @@ mpfr_clear_overflow (void)
 void
 mpfr_clear_nanflag (void)
 {
-  __mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN;
+  __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN;
 }
 
 #undef mpfr_clear_inexflag
@@ -114,7 +114,7 @@ mpfr_clear_nanflag (void)
 void
 mpfr_clear_inexflag (void)
 {
-  __mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT;
+  __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT;
 }
 
 #undef mpfr_check_range
@@ -125,7 +125,7 @@ mpfr_check_range (mpfr_ptr x, int t, mp_rnd_t rnd_mode)
   if (MPFR_IS_FP(x) && MPFR_NOTZERO(x))
     { /* x is a non-zero FP */
       mp_exp_t exp = MPFR_EXP(x);
-      if (exp < __mpfr_emin)
+      if (exp < __gmpfr_emin)
         {
           /* The following test is necessary because in the rounding to the
            * nearest mode, mpfr_set_underflow always rounds away from 0. In
@@ -135,13 +135,13 @@ mpfr_check_range (mpfr_ptr x, int t, mp_rnd_t rnd_mode)
            *     result is <= 2^(emin-2).
            */
           if (rnd_mode == GMP_RNDN &&
-              (exp + 1 < __mpfr_emin ||
+              (exp + 1 < __gmpfr_emin ||
                (mpfr_powerof2_raw(x) &&
                 (MPFR_SIGN(x) < 0 ? t <= 0 : t >= 0))))
             rnd_mode = GMP_RNDZ;
           return mpfr_set_underflow(x, rnd_mode, MPFR_SIGN(x));
         }
-      if (exp > __mpfr_emax)
+      if (exp > __gmpfr_emax)
         return mpfr_set_overflow(x, rnd_mode, MPFR_SIGN(x));
     }
   return t;  /* propagate inexact ternary value, unlike most functions */
@@ -152,7 +152,7 @@ mpfr_check_range (mpfr_ptr x, int t, mp_rnd_t rnd_mode)
 int
 mpfr_underflow_p (void)
 {
-  return __mpfr_flags & MPFR_FLAGS_UNDERFLOW;
+  return __gmpfr_flags & MPFR_FLAGS_UNDERFLOW;
 }
 
 #undef mpfr_overflow_p
@@ -160,7 +160,7 @@ mpfr_underflow_p (void)
 int
 mpfr_overflow_p (void)
 {
-  return __mpfr_flags & MPFR_FLAGS_OVERFLOW;
+  return __gmpfr_flags & MPFR_FLAGS_OVERFLOW;
 }
 
 #undef mpfr_nanflag_p
@@ -168,7 +168,7 @@ mpfr_overflow_p (void)
 int
 mpfr_nanflag_p (void)
 {
-  return __mpfr_flags & MPFR_FLAGS_NAN;
+  return __gmpfr_flags & MPFR_FLAGS_NAN;
 }
 
 #undef mpfr_inexflag_p
@@ -176,7 +176,7 @@ mpfr_nanflag_p (void)
 int
 mpfr_inexflag_p (void)
 {
-  return __mpfr_flags & MPFR_FLAGS_INEXACT;
+  return __gmpfr_flags & MPFR_FLAGS_INEXACT;
 }
 
 #undef mpfr_set_underflow
@@ -196,7 +196,7 @@ mpfr_set_underflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
       || (rnd_mode == GMP_RNDU && sign > 0)
       || (rnd_mode == GMP_RNDD && sign < 0))
     {
-      mpfr_setmin (x, __mpfr_emin);
+      mpfr_setmin (x, __gmpfr_emin);
       inex = 1;
     }
   else
@@ -206,7 +206,7 @@ mpfr_set_underflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
     }
   if (MPFR_SIGN(x) != sign)
     MPFR_CHANGE_SIGN(x);
-  __mpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_UNDERFLOW;
+  __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_UNDERFLOW;
   return sign > 0 ? inex : -inex;
 }
 
@@ -221,7 +221,7 @@ mpfr_set_overflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
   if ((rnd_mode == GMP_RNDU && sign < 0)
    || (rnd_mode == GMP_RNDD && sign > 0))
     {
-      mpfr_setmax (x, __mpfr_emax);
+      mpfr_setmax (x, __gmpfr_emax);
       inex = -1;
     }
   else
@@ -231,6 +231,6 @@ mpfr_set_overflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
     }
   if (MPFR_SIGN(x) != sign)
     MPFR_CHANGE_SIGN(x);
-  __mpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_OVERFLOW;
+  __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_OVERFLOW;
   return sign > 0 ? inex : -inex;
 }
diff --git a/exp.c b/exp.c
index 4aa50f612..651c2ca32 100644
--- a/exp.c
+++ b/exp.c
@@ -69,15 +69,15 @@ mpfr_exp (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
   expx = MPFR_EXP(x);
   precy = MPFR_PREC(y);
 
-  /* result is +Inf when exp(x) >= 2^(__mpfr_emax), i.e.
-     x >= __mpfr_emax * log(2) */
+  /* result is +Inf when exp(x) >= 2^(__gmpfr_emax), i.e.
+     x >= __gmpfr_emax * log(2) */
   d = mpfr_get_d1 (x);
-  if (d >= (double) __mpfr_emax * LOG2)
+  if (d >= (double) __gmpfr_emax * LOG2)
     return mpfr_set_overflow(y, rnd_mode, 1);
 
-  /* result is 0 when exp(x) < 1/2*2^(__mpfr_emin), i.e.
-     x < (__mpfr_emin-1) * LOG2 */
-  if (d < ((double) __mpfr_emin - 1.0) * LOG2)
+  /* result is 0 when exp(x) < 1/2*2^(__gmpfr_emin), i.e.
+     x < (__gmpfr_emin-1) * LOG2 */
+  if (d < ((double) __gmpfr_emin - 1.0) * LOG2)
     return mpfr_set_underflow(y, rnd_mode, 1);
 
   /* if x < 2^(-precy), then exp(x) i.e. gives 1 +/- 1 ulp(1) */
diff --git a/exp2.c b/exp2.c
index 48cc8b95c..6f93c8eec 100644
--- a/exp2.c
+++ b/exp2.c
@@ -62,9 +62,9 @@ mpfr_exp2 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
     if (MPFR_IS_ZERO(x))
       return mpfr_set_ui (y, 1, rnd_mode);
 
-    /* since the smallest representable non-zero float is 1/2*2^__mpfr_emin,
-       if x < __mpfr_emin - 1, the result is either 1/2*2^__mpfr_emin or 0 */
-    if (mpfr_cmp_si_2exp (x, __mpfr_emin - 1, 0) < 0)
+    /* since the smallest representable non-zero float is 1/2*2^__gmpfr_emin,
+       if x < __gmpfr_emin - 1, the result is either 1/2*2^__gmpfr_emin or 0 */
+    if (mpfr_cmp_si_2exp (x, __gmpfr_emin - 1, 0) < 0)
       return mpfr_set_underflow (y, rnd_mode, 1);
 
     /* General case */
@@ -82,7 +82,7 @@ mpfr_exp2 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
       /* compute the precision of intermediary variable */
       Nt = MAX(Nx, Ny);
       /* the optimal number of bits : see algorithms.ps */
-      Nt = Nt + 5 + _mpfr_ceil_log2 (Nt);
+      Nt = Nt + 5 + __gmpfr_ceil_log2 (Nt);
 
 
       /* initialise of intermediary	variable */
@@ -105,7 +105,7 @@ mpfr_exp2 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
 	err = Nt - (MPFR_EXP(te) + 2);
 
 	/* actualisation of the precision */
-	Nt += _mpfr_isqrt (Nt) + 10;
+	Nt += __gmpfr_isqrt (Nt) + 10;
 
       } while ((err < 0) || !mpfr_can_round (t, err, GMP_RNDN, rnd_mode, Ny));
  
diff --git a/exp3.c b/exp3.c
index 5ec4b65ee..ce022126b 100644
--- a/exp3.c
+++ b/exp3.c
@@ -77,7 +77,7 @@ mpfr_exp_rational (mpfr_ptr y, mpz_srcptr p, int r, int m)
    l = 0;
    accu = 0;
    while (k > 0){
-     mpz_mul(S[k], S[k], ptoj[_mpfr_ceil_log2((double) nb_terms[k])]);
+     mpz_mul(S[k], S[k], ptoj[__gmpfr_ceil_log2((double) nb_terms[k])]);
      mpz_mul(S[k-1], S[k-1], P[k]);
      accu += nb_terms[k];
      mpz_mul_2exp(S[k-1], S[k-1], r* accu);
@@ -139,9 +139,9 @@ mpfr_exp3 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
   /* decompose x */
   /* we first write x = 1.xxxxxxxxxxxxx
      ----- k bits -- */
-  prec_x = _mpfr_ceil_log2 ((double) (MPFR_PREC(x)) / BITS_PER_MP_LIMB);
+  prec_x = __gmpfr_ceil_log2 ((double) (MPFR_PREC(x)) / BITS_PER_MP_LIMB);
   if (prec_x < 0) prec_x = 0;
-  logn =  _mpfr_ceil_log2 ((double) prec_x + MPFR_PREC(y));
+  logn =  __gmpfr_ceil_log2 ((double) prec_x + MPFR_PREC(y));
   if (logn < 2) logn = 2;
   ttt = MPFR_EXP(x);
   mpfr_init2(x_copy,MPFR_PREC(x));
@@ -157,7 +157,7 @@ mpfr_exp3 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
   mpz_init (uk);
   while (!good){      
     Prec = realprec+shift+2+shift_x;
-    k = _mpfr_ceil_log2 ((double) Prec / BITS_PER_MP_LIMB);
+    k = __gmpfr_ceil_log2 ((double) Prec / BITS_PER_MP_LIMB);
 
     /* now we have to extract */
     mpfr_init2 (t, Prec);
diff --git a/exp_2.c b/exp_2.c
index 135f1d04c..52af6ffd3 100644
--- a/exp_2.c
+++ b/exp_2.c
@@ -33,7 +33,7 @@ static int mpz_normalize2     _PROTO ((mpz_t, mpz_t, int, int));
 
 /* returns floor(sqrt(n)) */
 unsigned long
-_mpfr_isqrt (unsigned long n)
+__gmpfr_isqrt (unsigned long n)
 {
   unsigned long s;
 
@@ -46,7 +46,7 @@ _mpfr_isqrt (unsigned long n)
 
 /* returns floor(n^(1/3)) */
 unsigned long
-_mpfr_cuberoot (unsigned long n)
+__gmpfr_cuberoot (unsigned long n)
 {
   double s, is;
 
@@ -118,9 +118,9 @@ mpfr_exp_2 (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
   /* for the O(n^(1/2)*M(n)) method, the Taylor series computation of
      n/K terms costs about n/(2K) multiplications when computed in fixed
      point */
-  K = (precy<SWITCH) ? _mpfr_isqrt((precy + 1) / 2) : _mpfr_cuberoot (4*precy);
+  K = (precy<SWITCH) ? __gmpfr_isqrt((precy + 1) / 2) : __gmpfr_cuberoot (4*precy);
   l = (precy-1)/K + 1;
-  err = K + (int) _mpfr_ceil_log2 (2.0 * (double) l + 18.0);
+  err = K + (int) __gmpfr_ceil_log2 (2.0 * (double) l + 18.0);
   /* add K extra bits, i.e. failure probability <= 1/2^K = O(1/precy) */
   q = precy + err + K + 3;
   mpfr_init2 (r, q);
@@ -284,7 +284,7 @@ mpfr_exp2_aux2 (mpz_t s, mpfr_srcptr r, int q, int *exps)
 
   /* estimate value of l */
   l = q / (-MPFR_EXP(r));
-  m = (int) _mpfr_isqrt (l);
+  m = (int) __gmpfr_isqrt (l);
   /* we access R[2], thus we need m >= 2 */
   if (m < 2) m = 2;
   TMP_MARK(marker);
diff --git a/expm1.c b/expm1.c
index 0fc5af169..3980a4110 100644
--- a/expm1.c
+++ b/expm1.c
@@ -79,7 +79,7 @@ mpfr_expm1 (mpfr_ptr y, mpfr_srcptr x , mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt=MAX(Nx,Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt=Nt+5+_mpfr_ceil_log2(Nt);
+    Nt=Nt+5+__gmpfr_ceil_log2(Nt);
 
     /* initialise of intermediary	variable */
     mpfr_init(t);             
@@ -97,7 +97,7 @@ mpfr_expm1 (mpfr_ptr y, mpfr_srcptr x , mp_rnd_t rnd_mode)
       mpfr_sub_ui(t,te,1,GMP_RNDN);   /* exp(x)-1 */
 
       /* estimation of the error */
-      /*err=Nt-(_mpfr_ceil_log2(1+pow(2,MPFR_EXP(te)-MPFR_EXP(t))));*/
+      /*err=Nt-(__gmpfr_ceil_log2(1+pow(2,MPFR_EXP(te)-MPFR_EXP(t))));*/
       err=Nt-(MAX(MPFR_EXP(te)-MPFR_EXP(t),0)+1);
 
       /* actualisation of the precision */
diff --git a/factorial.c b/factorial.c
index 0980308bd..d4f1992b9 100644
--- a/factorial.c
+++ b/factorial.c
@@ -56,7 +56,7 @@ mpfr_fac_ui (mpfr_ptr y, unsigned long int x , mp_rnd_t rnd_mode)
         /* Initialisation of the Precision */
 	Ny=MPFR_PREC(y);
         
-	Nt=Ny+2*(int)_mpfr_ceil_log2((double)x)+10; /*compute the size of intermediary variable */
+	Nt=Ny+2*(int)__gmpfr_ceil_log2((double)x)+10; /*compute the size of intermediary variable */
 
 	
         mpfr_init2(t, Nt);/* initialise of intermediary variable */
@@ -74,7 +74,7 @@ mpfr_fac_ui (mpfr_ptr y, unsigned long int x , mp_rnd_t rnd_mode)
                   inexact = round;
               }
 	    
-            err = Nt - 1 - (int) _mpfr_ceil_log2 ((double) Nt);
+            err = Nt - 1 - (int) __gmpfr_ceil_log2 ((double) Nt);
 
             round = !inexact || mpfr_can_round (t,err,GMP_RNDZ,rnd_mode,Ny);
             
diff --git a/gamma.c b/gamma.c
index 98d80bf07..c92bf496a 100644
--- a/gamma.c
+++ b/gamma.c
@@ -198,7 +198,7 @@ mpfr_gamma (mpfr_ptr gamma, mpfr_srcptr x, mp_rnd_t rnd_mode)
       }
     else
       {
-	realprec += _mpfr_ceil_log2 ((double) realprec);
+	realprec += __gmpfr_ceil_log2 ((double) realprec);
 #ifdef DEBUG
 	printf("RETRY\n");
 #endif
diff --git a/gammaPiAGMformula.c b/gammaPiAGMformula.c
index 96174e553..82f590c6e 100644
--- a/gammaPiAGMformula.c
+++ b/gammaPiAGMformula.c
@@ -205,7 +205,7 @@ mpfr_gamma (gamma, x, rnd_mode)
       }
     else
       {
-	realprec += _mpfr_ceil_log2 ((double) realprec);
+	realprec += __gmpfr_ceil_log2 ((double) realprec);
 #ifdef DEBUG
 	printf("RETRY\n");
 #endif
diff --git a/get_d.c b/get_d.c
index 1eab9493a..8ea226eaa 100644
--- a/get_d.c
+++ b/get_d.c
@@ -193,5 +193,5 @@ double
 mpfr_get_d1 (mpfr_srcptr src)
 {
   return mpfr_get_d3 (src, MPFR_IS_FP(src) && MPFR_NOTZERO(src) ?
-                      MPFR_EXP(src) : 0, __gmp_default_rounding_mode);
+                      MPFR_EXP(src) : 0, __gmpfr_default_rounding_mode);
 }
diff --git a/get_str.c b/get_str.c
index be7afbaff..9fe3f9729 100644
--- a/get_str.c
+++ b/get_str.c
@@ -680,10 +680,10 @@ mpfr_get_str (char *s, mp_exp_t *e, int b, size_t m, mpfr_srcptr x, mp_rnd_t rnd
   exact = 1;
   prec = (mp_exp_t) _mpfr_ceil ((double) m / log_b2[b-2]) + 1;
   exp = ((mp_exp_t) m < g) ? g - (mp_exp_t) m : (mp_exp_t) m - g;
-  log_2prec = (mp_exp_t) _mpfr_ceil_log2 ((double) prec);
+  log_2prec = (mp_exp_t) __gmpfr_ceil_log2 ((double) prec);
   prec += log_2prec; /* number of guard bits */
   if (exp != 0) /* add maximal exponentiation error */
-    prec += 3 * (mp_exp_t) _mpfr_ceil_log2 ((double) exp);
+    prec += 3 * (mp_exp_t) __gmpfr_ceil_log2 ((double) exp);
 
   for (;;)
     {
diff --git a/get_z_exp.c b/get_z_exp.c
index d1b9eca77..c409b9b59 100644
--- a/get_z_exp.c
+++ b/get_z_exp.c
@@ -29,8 +29,8 @@ MA 02111-1307, USA. */
 /* puts the mantissa of f into z, and returns 'exp' such that f = z * 2^exp
  *
  * 0 doesn't have an exponent, therefore the returned exponent in this case
- * isn't really important. We choose to return __mpfr_emin because
- *   1) it is in the exponent range [__mpfr_emin,__mpfr_emax],
+ * isn't really important. We choose to return __gmpfr_emin because
+ *   1) it is in the exponent range [__gmpfr_emin,__gmpfr_emax],
  *   2) the smaller a number is (in absolute value), the smaller its
  *      exponent is. In other words, the f -> exp function is monotonous
  *      on nonnegative numbers.
@@ -48,7 +48,7 @@ mpfr_get_z_exp (mpz_ptr z, mpfr_srcptr f)
   if (MPFR_IS_ZERO(f))
     {
       mpz_set_ui (z, 0);
-      return __mpfr_emin;
+      return __gmpfr_emin;
     }
 
   fn = 1 + (MPFR_PREC(f) - 1) / BITS_PER_MP_LIMB;
diff --git a/hypot.c b/hypot.c
index 7153b9e7e..b9ee05877 100644
--- a/hypot.c
+++ b/hypot.c
@@ -114,7 +114,7 @@ mpfr_hypot (mpfr_ptr z, mpfr_srcptr x , mpfr_srcptr y , mp_rnd_t rnd_mode)
       
   /* compute the working precision -- see algorithms.ps */
   Nt = MAX(MAX(MAX(Nx, Ny), Nz), 8);
-  Nt = Nt - 8 + _mpfr_ceil_log2 (Nt);
+  Nt = Nt - 8 + __gmpfr_ceil_log2 (Nt);
 
   /* initialise the intermediary variables */
   mpfr_init (t);
diff --git a/init.c b/init.c
index 91df0c394..dbc0c645f 100644
--- a/init.c
+++ b/init.c
@@ -27,5 +27,5 @@ MA 02111-1307, USA. */
 void
 mpfr_init (mpfr_ptr x)
 {
-  mpfr_init2 (x, __mpfr_default_fp_bit_precision);
+  mpfr_init2 (x, __gmpfr_default_fp_bit_precision);
 }
diff --git a/log10.c b/log10.c
index 0d4dfbdbe..df8854da5 100644
--- a/log10.c
+++ b/log10.c
@@ -101,7 +101,7 @@ mpfr_log10 (mpfr_ptr r, mpfr_srcptr a, mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt = MAX(Nx, Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt = Nt + 4+ _mpfr_ceil_log2 (Nt);
+    Nt = Nt + 4+ __gmpfr_ceil_log2 (Nt);
 
     /* initialise of intermediary variables */
     mpfr_init (t);
diff --git a/log1p.c b/log1p.c
index 92861ad02..89d767d5d 100644
--- a/log1p.c
+++ b/log1p.c
@@ -97,7 +97,7 @@ mpfr_log1p (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt=MAX(Nx,Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt=Nt+5+_mpfr_ceil_log2(Nt);
+    Nt=Nt+5+__gmpfr_ceil_log2(Nt);
 
     /* initialise of intermediary variable */
     mpfr_init(t);             
@@ -113,7 +113,7 @@ mpfr_log1p (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
       mpfr_log (t, t, GMP_RNDN);        /* log(1+x)*/
 
       /* estimation of the error */
-      /*err=Nt-(_mpfr_ceil_log2(1+pow(2,1-MPFR_EXP(t))));*/
+      /*err=Nt-(__gmpfr_ceil_log2(1+pow(2,1-MPFR_EXP(t))));*/
       err=Nt-(MAX(1-MPFR_EXP(t),0)+1);
 
       /* actualisation of the precision */
diff --git a/log2.c b/log2.c
index 5205c328b..c245a8f5c 100644
--- a/log2.c
+++ b/log2.c
@@ -106,7 +106,7 @@ mpfr_log2 (mpfr_ptr r, mpfr_srcptr a, mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt=MAX(Nx,Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt=Nt+3+_mpfr_ceil_log2(Nt);
+    Nt=Nt+3+__gmpfr_ceil_log2(Nt);
 
     /* initialise of intermediary	variable */
     mpfr_init(t);             
diff --git a/mpf2mpfr.h b/mpf2mpfr.h
index 7e30aa9be..723c9f3fb 100644
--- a/mpf2mpfr.h
+++ b/mpf2mpfr.h
@@ -52,7 +52,7 @@ MA 02111-1307, USA. */
 #undef mpf_get_default_prec
 #define mpf_get_default_prec mpfr_get_default_prec
 #undef mpf_set_prec
-#define mpf_set_prec(x,p) mpfr_round_prec(x, __gmp_default_rounding_mode, p)
+#define mpf_set_prec(x,p) mpfr_round_prec(x, __gmpfr_default_rounding_mode, p)
 #undef mpf_set_prec_raw
 #define mpf_set_prec_raw mpfr_set_prec_raw
 #undef mpf_trunc
@@ -64,77 +64,77 @@ MA 02111-1307, USA. */
 
 /* functions which take as argument the rounding mode */
 #undef mpf_abs
-#define mpf_abs(x,y) mpfr_abs(x,y,__gmp_default_rounding_mode)
+#define mpf_abs(x,y) mpfr_abs(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_add
-#define mpf_add(x,y,z) mpfr_add(x,y,z,__gmp_default_rounding_mode)
+#define mpf_add(x,y,z) mpfr_add(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_add_ui
 #define mpf_add_ui(x,y,z) \
-             mpfr_add_ui(x,y,z,__gmp_default_rounding_mode)
+             mpfr_add_ui(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_div
-#define mpf_div(x,y,z) mpfr_div(x,y,z,__gmp_default_rounding_mode)
+#define mpf_div(x,y,z) mpfr_div(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_div_ui
 #define mpf_div_ui(x,y,z) \
-                          mpfr_div_ui(x,y,z,__gmp_default_rounding_mode)
+                          mpfr_div_ui(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_div_2exp
 #define mpf_div_2exp(x,y,z) \
-                         mpfr_div_2exp(x,y,z,__gmp_default_rounding_mode)
+                         mpfr_div_2exp(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_dump
 #define mpf_dump(x,y,z) \
-                mpfr_dump(x,y,z,__gmp_default_rounding_mode)
+                mpfr_dump(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_get_str
 #define mpf_get_str(x,y,z,t,u) \
-               mpfr_get_str(x,y,z,t,u,__gmp_default_rounding_mode)
+               mpfr_get_str(x,y,z,t,u,__gmpfr_default_rounding_mode)
 #undef mpf_inp_str
-#define mpf_inp_str(x,y,z) mpfr_inp_str(x,y,z,__gmp_default_rounding_mode)
+#define mpf_inp_str(x,y,z) mpfr_inp_str(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_set_str
-#define mpf_set_str(x,y,z) mpfr_set_str(x,y,z,__gmp_default_rounding_mode)
+#define mpf_set_str(x,y,z) mpfr_set_str(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_init_set
-#define mpf_init_set(x,y) mpfr_init_set(x,y,__gmp_default_rounding_mode)
+#define mpf_init_set(x,y) mpfr_init_set(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_init_set_d
-#define mpf_init_set_d(x,y) mpfr_init_set_d(x,y,__gmp_default_rounding_mode)
+#define mpf_init_set_d(x,y) mpfr_init_set_d(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_init_set_si
-#define mpf_init_set_si(x,y) mpfr_init_set_si(x,y,__gmp_default_rounding_mode)
+#define mpf_init_set_si(x,y) mpfr_init_set_si(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_init_set_str
-#define mpf_init_set_str(x,y,z) mpfr_init_set_str(x,y,z,__gmp_default_rounding_mode)
+#define mpf_init_set_str(x,y,z) mpfr_init_set_str(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_init_set_ui
-#define mpf_init_set_ui(x,y) mpfr_init_set_ui(x,y,__gmp_default_rounding_mode)
+#define mpf_init_set_ui(x,y) mpfr_init_set_ui(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_mul
-#define mpf_mul(x,y,z) mpfr_mul(x,y,z,__gmp_default_rounding_mode)
+#define mpf_mul(x,y,z) mpfr_mul(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_mul_2exp
-#define mpf_mul_2exp(x,y,z) mpfr_mul_2exp(x,y,z,__gmp_default_rounding_mode)
+#define mpf_mul_2exp(x,y,z) mpfr_mul_2exp(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_mul_ui
-#define mpf_mul_ui(x,y,z) mpfr_mul_ui(x,y,z,__gmp_default_rounding_mode)
+#define mpf_mul_ui(x,y,z) mpfr_mul_ui(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_neg
-#define mpf_neg(x,y) mpfr_neg(x,y,__gmp_default_rounding_mode)
+#define mpf_neg(x,y) mpfr_neg(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_out_str
-#define mpf_out_str(x,y,z,t) mpfr_out_str(x,y,z,t,__gmp_default_rounding_mode)
+#define mpf_out_str(x,y,z,t) mpfr_out_str(x,y,z,t,__gmpfr_default_rounding_mode)
 #undef mpf_pow_ui
-#define mpf_pow_ui(x,y,z) mpfr_pow_ui(x,y,z,__gmp_default_rounding_mode)
+#define mpf_pow_ui(x,y,z) mpfr_pow_ui(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_reldiff
-#define mpf_reldiff(x,y,z) mpfr_reldiff(x,y,z,__gmp_default_rounding_mode)
+#define mpf_reldiff(x,y,z) mpfr_reldiff(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_set
-#define mpf_set(x,y) mpfr_set(x,y,__gmp_default_rounding_mode)
+#define mpf_set(x,y) mpfr_set(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_set_d
-#define mpf_set_d(x,y) mpfr_set_d(x,y,__gmp_default_rounding_mode)
+#define mpf_set_d(x,y) mpfr_set_d(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_set_q
-#define mpf_set_q(x,y) mpfr_set_q(x,y,__gmp_default_rounding_mode)
+#define mpf_set_q(x,y) mpfr_set_q(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_set_si
-#define mpf_set_si(x,y) mpfr_set_si(x,y,__gmp_default_rounding_mode)
+#define mpf_set_si(x,y) mpfr_set_si(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_set_ui
-#define mpf_set_ui(x,y) mpfr_set_ui(x,y,__gmp_default_rounding_mode)
+#define mpf_set_ui(x,y) mpfr_set_ui(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_set_z
-#define mpf_set_z(x,y) mpfr_set_z(x,y,__gmp_default_rounding_mode)
+#define mpf_set_z(x,y) mpfr_set_z(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_sqrt
-#define mpf_sqrt(x,y) mpfr_sqrt(x,y,__gmp_default_rounding_mode)
+#define mpf_sqrt(x,y) mpfr_sqrt(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_sqrt_ui
-#define mpf_sqrt_ui(x,y) mpfr_sqrt_ui(x,y,__gmp_default_rounding_mode)
+#define mpf_sqrt_ui(x,y) mpfr_sqrt_ui(x,y,__gmpfr_default_rounding_mode)
 #undef mpf_sub
-#define mpf_sub(x,y,z) mpfr_sub(x,y,z,__gmp_default_rounding_mode)
+#define mpf_sub(x,y,z) mpfr_sub(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_sub_ui
-#define mpf_sub_ui(x,y,z) mpfr_sub_ui(x,y,z,__gmp_default_rounding_mode)
+#define mpf_sub_ui(x,y,z) mpfr_sub_ui(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_ui_div
-#define mpf_ui_div(x,y,z) mpfr_ui_div(x,y,z,__gmp_default_rounding_mode)
+#define mpf_ui_div(x,y,z) mpfr_ui_div(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_ui_sub
-#define mpf_ui_sub(x,y,z) mpfr_ui_sub(x,y,z,__gmp_default_rounding_mode)
+#define mpf_ui_sub(x,y,z) mpfr_ui_sub(x,y,z,__gmpfr_default_rounding_mode)
 #undef mpf_urandomb
 #define mpf_urandomb(x,y,n) mpfr_urandomb(x,y)
diff --git a/mpfr-impl.h b/mpfr-impl.h
index 1c418151a..5c30036d3 100644
--- a/mpfr-impl.h
+++ b/mpfr-impl.h
@@ -150,8 +150,8 @@ typedef union ieee_double_extract Ieee_double_extract;
    following two macros, unless the flag comes from another function
    returning the ternary inexact value */
 #define MPFR_RET(I) return \
-  (I) ? ((__mpfr_flags |= MPFR_FLAGS_INEXACT), (I)) : 0
-#define MPFR_RET_NAN return (__mpfr_flags |= MPFR_FLAGS_NAN), 0
+  (I) ? ((__gmpfr_flags |= MPFR_FLAGS_INEXACT), (I)) : 0
+#define MPFR_RET_NAN return (__gmpfr_flags |= MPFR_FLAGS_NAN), 0
 
 /* Memory gestion */
 
@@ -179,12 +179,10 @@ extern "C" {
 #endif  
 
 extern mpfr_t __mpfr_const_log2;
-#define __mpfr_const_log2_prec __gmpfr_const_log2_prec
-extern mp_prec_t __mpfr_const_log2_prec;
+extern mp_prec_t __gmpfr_const_log2_prec;
 
 extern mpfr_t __mpfr_const_pi;
-#define __mpfr_const_pi_prec __gmpfr_const_pi_prec
-extern mp_prec_t __mpfr_const_pi_prec;
+extern mp_prec_t __gmpfr_const_pi_prec;
 
 #ifndef HAVE_STRCASECMP
 int mpfr_strcasecmp _PROTO ((const char *, const char *));
@@ -208,16 +206,11 @@ int mpfr_can_round_raw _PROTO ((mp_limb_t *, mp_size_t, int, mp_exp_t,
 				mp_rnd_t, mp_rnd_t, mp_prec_t));
 double mpfr_get_d3 _PROTO ((mpfr_srcptr, mp_exp_t, mp_rnd_t));
 int mpfr_cmp2 _PROTO ((mpfr_srcptr, mpfr_srcptr, mp_prec_t *));
-#define _mpfr_ceil_log2 __gmpfr_ceil_log2
-long _mpfr_ceil_log2 _PROTO ((double));
-#define _mpfr_floor_log2 __gmpfr_floor_log2
-long _mpfr_floor_log2 _PROTO ((double));
-#define _mpfr_ceil_exp2 __gmpfr_ceil_exp2
-double _mpfr_ceil_exp2 _PROTO ((double));
-#define _mpfr_isqrt __gmpfr_isqrt
-unsigned long _mpfr_isqrt _PROTO ((unsigned long));
-#define _mpfr_cuberoot __gmpfr_cuberoot
-unsigned long _mpfr_cuberoot _PROTO ((unsigned long));
+long __gmpfr_ceil_log2 _PROTO ((double));
+long __gmpfr_floor_log2 _PROTO ((double));
+double __gmpfr_ceil_exp2 _PROTO ((double));
+unsigned long __gmpfr_isqrt _PROTO ((unsigned long));
+unsigned long __gmpfr_cuberoot _PROTO ((unsigned long));
 int mpfr_exp_2 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
 int mpfr_exp3 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
 int mpfr_powerof2_raw _PROTO ((mpfr_srcptr));
diff --git a/mpfr.h b/mpfr.h
index 8cd092c06..57205d538 100644
--- a/mpfr.h
+++ b/mpfr.h
@@ -118,12 +118,9 @@ typedef __gmp_const __mpfr_struct *mpfr_srcptr;
 extern "C" {
 #endif  
 
-#define __mpfr_flags __gmpfr_flags
-extern unsigned int __mpfr_flags;
-#define __mpfr_emin __gmpfr_emin
-extern mp_exp_t __mpfr_emin;
-#define __mpfr_emax __gmpfr_emax
-extern mp_exp_t __mpfr_emax;
+extern unsigned int __gmpfr_flags;
+extern mp_exp_t __gmpfr_emin;
+extern mp_exp_t __gmpfr_emax;
 mp_exp_t mpfr_get_emin _PROTO ((void));
 int mpfr_set_emin _PROTO ((mp_exp_t));
 mp_exp_t mpfr_get_emax _PROTO ((void));
@@ -213,10 +210,8 @@ void mpfr_set_prec _PROTO((mpfr_ptr, mp_prec_t));
 void mpfr_set_prec_raw _PROTO((mpfr_ptr, mp_prec_t));
 void mpfr_set_default_prec _PROTO((mp_prec_t));
 mp_prec_t mpfr_get_default_prec _PROTO((void));
-#define __mpfr_default_fp_bit_precision __gmpfr_default_fp_bit_precision
-extern mp_prec_t __mpfr_default_fp_bit_precision;
-#define __gmp_default_rounding_mode __gmpfr_default_rounding_mode
-extern mp_rnd_t __gmp_default_rounding_mode;
+extern mp_prec_t __gmpfr_default_fp_bit_precision;
+extern mp_rnd_t __gmpfr_default_rounding_mode;
 char * mpfr_print_rnd_mode _PROTO((mp_rnd_t)); 
 int mpfr_neg _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t)); 
 int mpfr_sub_one_ulp _PROTO((mpfr_ptr, mp_rnd_t));
@@ -300,27 +295,27 @@ int mpfr_unordered_p _PROTO ((mpfr_srcptr, mpfr_srcptr));
 #endif  
 
 /* prevent from using mpfr_get_e{min,max} as lvalues */
-#define mpfr_get_emin() (__mpfr_emin + 0)
-#define mpfr_get_emax() (__mpfr_emax + 0)
+#define mpfr_get_emin() (__gmpfr_emin + 0)
+#define mpfr_get_emax() (__gmpfr_emax + 0)
 
 #define mpfr_clear_flags() \
-  ((void) (__mpfr_flags = 0))
+  ((void) (__gmpfr_flags = 0))
 #define mpfr_clear_underflow() \
-  ((void) (__mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW))
+  ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW))
 #define mpfr_clear_overflow() \
-  ((void) (__mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW))
+  ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW))
 #define mpfr_clear_nanflag() \
-  ((void) (__mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN))
+  ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN))
 #define mpfr_clear_inexflag() \
-  ((void) (__mpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT))
+  ((void) (__gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT))
 #define mpfr_underflow_p() \
-  ((int) (__mpfr_flags & MPFR_FLAGS_UNDERFLOW))
+  ((int) (__gmpfr_flags & MPFR_FLAGS_UNDERFLOW))
 #define mpfr_overflow_p() \
-  ((int) (__mpfr_flags & MPFR_FLAGS_OVERFLOW))
+  ((int) (__gmpfr_flags & MPFR_FLAGS_OVERFLOW))
 #define mpfr_nanflag_p() \
-  ((int) (__mpfr_flags & MPFR_FLAGS_NAN))
+  ((int) (__gmpfr_flags & MPFR_FLAGS_NAN))
 #define mpfr_inexflag_p() \
-  ((int) (__mpfr_flags & MPFR_FLAGS_INEXACT))
+  ((int) (__gmpfr_flags & MPFR_FLAGS_INEXACT))
 
 #define mpfr_round(a,b) mpfr_rint((a), (b), GMP_RNDN)
 #define mpfr_trunc(a,b) mpfr_rint((a), (b), GMP_RNDZ)
diff --git a/mul.c b/mul.c
index d7322a95f..66dcaf8a9 100644
--- a/mul.c
+++ b/mul.c
@@ -94,9 +94,9 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode)
      ec in {-1,0,1} and the following assumes that e is representable. */
   MPFR_ASSERTN(MPFR_EMAX_MAX <= (MP_EXP_T_MAX >> 1));
   MPFR_ASSERTN(MPFR_EMIN_MIN >= -(MP_EXP_T_MAX >> 1));
-  if (bx + cx > __mpfr_emax + 1)
+  if (bx + cx > __gmpfr_emax + 1)
     return mpfr_set_overflow (a, rnd_mode, sign_product);
-  if (bx + cx < __mpfr_emin - 2)
+  if (bx + cx < __gmpfr_emin - 2)
     return mpfr_set_underflow (a, rnd_mode == GMP_RNDN ? GMP_RNDZ : rnd_mode,
                                sign_product);
 
@@ -141,16 +141,16 @@ mpfr_mul (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode)
   TMP_FREE(marker);
 
   ax = (bx + cx) + (mp_exp_t) (b1 - 1 + cc);
-  if (ax > __mpfr_emax)
+  if (ax > __gmpfr_emax)
     return mpfr_set_overflow (a, rnd_mode, sign_product);
-  if (ax < __mpfr_emin)
+  if (ax < __gmpfr_emin)
     {
       /* In the rounding to the nearest mode, if the exponent of the exact
          result (i.e. before rounding, i.e. without taking cc into account)
-         is < __mpfr_emin - 1 or the exact result is a power of 2 (i.e. if
+         is < __gmpfr_emin - 1 or the exact result is a power of 2 (i.e. if
          both arguments are powers of 2), then round to zero. */
       if (rnd_mode == GMP_RNDN &&
-          ((bx + cx) + (mp_exp_t) b1 < __mpfr_emin ||
+          ((bx + cx) + (mp_exp_t) b1 < __gmpfr_emin ||
            (mpfr_powerof2_raw (b) && mpfr_powerof2_raw (c))))
         rnd_mode = GMP_RNDZ;
       return mpfr_set_underflow (a, rnd_mode, sign_product);
diff --git a/mul_2si.c b/mul_2si.c
index cdc522425..ad0b29f27 100644
--- a/mul_2si.c
+++ b/mul_2si.c
@@ -33,16 +33,16 @@ mpfr_mul_2si (mpfr_ptr y, mpfr_srcptr x, long int n, mp_rnd_t rnd_mode)
 
   if (MPFR_IS_FP(y) && MPFR_NOTZERO(y))
     {
-      if (n > 0 && (__mpfr_emax < MPFR_EMIN_MIN + n ||
-                    MPFR_EXP(y) > __mpfr_emax - n))
+      if (n > 0 && (__gmpfr_emax < MPFR_EMIN_MIN + n ||
+                    MPFR_EXP(y) > __gmpfr_emax - n))
         return mpfr_set_overflow (y, rnd_mode, MPFR_SIGN(y));
 
-      if (n < 0 && (__mpfr_emin > MPFR_EMAX_MAX + n ||
-                    MPFR_EXP(y) < __mpfr_emin - n))
+      if (n < 0 && (__gmpfr_emin > MPFR_EMAX_MAX + n ||
+                    MPFR_EXP(y) < __gmpfr_emin - n))
         {
           if (rnd_mode == GMP_RNDN &&
-              (__mpfr_emin > MPFR_EMAX_MAX + (n + 1) ||
-               MPFR_EXP(y) < __mpfr_emin - (n + 1) ||
+              (__gmpfr_emin > MPFR_EMAX_MAX + (n + 1) ||
+               MPFR_EXP(y) < __gmpfr_emin - (n + 1) ||
                mpfr_powerof2_raw (y)))
             rnd_mode = GMP_RNDZ;
           return mpfr_set_underflow (y, rnd_mode, MPFR_SIGN(y));
diff --git a/mul_2ui.c b/mul_2ui.c
index 5ce0404e8..575e21f64 100644
--- a/mul_2ui.c
+++ b/mul_2ui.c
@@ -48,8 +48,8 @@ mpfr_mul_2ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int n, mp_rnd_t rnd_mode)
       /* MPFR_EMIN_MIN + (long) n is signed and doesn't lead to an overflow;
          the first test useful so that the real test can't lead to an
          overflow. */
-      if (__mpfr_emax < MPFR_EMIN_MIN + (long) n ||
-          MPFR_EXP(y) > __mpfr_emax - (long) n)
+      if (__gmpfr_emax < MPFR_EMIN_MIN + (long) n ||
+          MPFR_EXP(y) > __gmpfr_emax - (long) n)
         return mpfr_set_overflow (y, rnd_mode, MPFR_SIGN(y));
 
       MPFR_EXP(y) += (long) n;
diff --git a/mul_ui.c b/mul_ui.c
index ee40251ea..d248d1c55 100644
--- a/mul_ui.c
+++ b/mul_ui.c
@@ -112,7 +112,7 @@ mpfr_mul_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mp_rnd_t rnd_mode)
 
   TMP_FREE(marker);
 
-  if (__mpfr_emax < MPFR_EMAX_MIN + cnt || MPFR_EXP(x) > __mpfr_emax - cnt)
+  if (__gmpfr_emax < MPFR_EMAX_MIN + cnt || MPFR_EXP(x) > __gmpfr_emax - cnt)
     return mpfr_set_overflow(y, rnd_mode, MPFR_SIGN(x));
 
   MPFR_EXP(y) = MPFR_EXP(x) + cnt;
diff --git a/next.c b/next.c
index 2f612d3df..974c3bf76 100644
--- a/next.c
+++ b/next.c
@@ -32,14 +32,14 @@ mpfr_nexttozero (mpfr_ptr x)
   if (MPFR_IS_INF(x))
     {
       MPFR_CLEAR_FLAGS(x);
-      mpfr_setmax (x, __mpfr_emax);
+      mpfr_setmax (x, __gmpfr_emax);
       return;
     }
 
   if (MPFR_IS_ZERO(x))
     {
       MPFR_CHANGE_SIGN(x);
-      mpfr_setmin (x, __mpfr_emin);
+      mpfr_setmin (x, __gmpfr_emin);
     }
   else
     {
@@ -54,7 +54,7 @@ mpfr_nexttozero (mpfr_ptr x)
       if (xp[xn-1] >> (BITS_PER_MP_LIMB - 1) == 0)
         { /* was an exact power of two: not normalized any more */
           mp_exp_t exp = MPFR_EXP(x);
-          if (exp == __mpfr_emin)
+          if (exp == __gmpfr_emin)
             MPFR_SET_ZERO(x);
           else
             {
@@ -75,7 +75,7 @@ mpfr_nexttoinf (mpfr_ptr x)
     return;
 
   if (MPFR_IS_ZERO(x))
-    mpfr_setmin (x, __mpfr_emin);
+    mpfr_setmin (x, __gmpfr_emin);
   else
     {
       mp_size_t xn;
@@ -88,7 +88,7 @@ mpfr_nexttoinf (mpfr_ptr x)
       if (mpn_add_1 (xp, xp, xn, MP_LIMB_T_ONE << sh)) /* got 1.0000... */
         {
           mp_exp_t exp = MPFR_EXP(x);
-          if (exp == __mpfr_emax)
+          if (exp == __gmpfr_emax)
             MPFR_SET_INF(x);
           else
             {
@@ -104,7 +104,7 @@ mpfr_nextabove (mpfr_ptr x)
 {
   if (MPFR_IS_NAN(x))
     {
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       return;
     }
 
@@ -119,7 +119,7 @@ mpfr_nextbelow (mpfr_ptr x)
 {
   if (MPFR_IS_NAN(x))
     {
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       return;
     }
 
@@ -136,7 +136,7 @@ mpfr_nexttoward (mpfr_ptr x, mpfr_srcptr y)
 
   if (MPFR_IS_NAN(x) || MPFR_IS_NAN(y))
     {
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       return;
     }
 
diff --git a/pow.c b/pow.c
index 1333e9d99..4433fb881 100644
--- a/pow.c
+++ b/pow.c
@@ -265,7 +265,7 @@ mpfr_pow (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y, mp_rnd_t rnd_mode)
     /* compute the precision of intermediary variable */
     Nt=MAX(Nx,Ny);
     /* the optimal number of bits : see algorithms.ps */
-    Nt=Nt+5+_mpfr_ceil_log2(Nt);
+    Nt=Nt+5+__gmpfr_ceil_log2(Nt);
 
     /* initialise of intermediary variable */
     mpfr_init(t);
diff --git a/pow_si.c b/pow_si.c
index 56d3ee69a..61474821f 100644
--- a/pow_si.c
+++ b/pow_si.c
@@ -90,7 +90,7 @@ mpfr_pow_si (mpfr_ptr y, mpfr_srcptr x, long int n, mp_rnd_t rnd_mode)
         /* compute the precision of intermediary variable */
         Nt=MAX(Nx,Ny);
         /* the optimal number of bits : see algorithms.ps */
-        Nt=Nt+3+_mpfr_ceil_log2(Nt);
+        Nt=Nt+3+__gmpfr_ceil_log2(Nt);
 
         /* initialise of intermediary	variable */
         mpfr_init(t);
diff --git a/rint.c b/rint.c
index 059b158d4..89ebc66fd 100644
--- a/rint.c
+++ b/rint.c
@@ -212,7 +212,7 @@ mpfr_rint (mpfr_ptr r, mpfr_srcptr u, mp_rnd_t rnd_mode)
            (rnd_mode == GMP_RNDU && sign > 0))
           && mpn_add_1(rp, rp, rn, MP_LIMB_T_ONE << sh))
         {
-          if (exp == __mpfr_emax)
+          if (exp == __gmpfr_emax)
             return mpfr_set_overflow(r, rnd_mode, MPFR_SIGN(r)) >= 0 ?
               uflags : -uflags;
           else
diff --git a/round_prec.c b/round_prec.c
index 3b6df663b..cfd066b7b 100644
--- a/round_prec.c
+++ b/round_prec.c
@@ -193,7 +193,7 @@ mpfr_round_prec (mpfr_ptr x, mp_rnd_t rnd_mode, mp_prec_t prec)
     {
       mp_exp_t exp = MPFR_EXP(x);
 
-      if (exp == __mpfr_emax)
+      if (exp == __gmpfr_emax)
         (void) mpfr_set_overflow(x, rnd_mode, MPFR_SIGN(x));
       else
         {
diff --git a/save_expo.c b/save_expo.c
index 500f4cbf9..5f2a83651 100644
--- a/save_expo.c
+++ b/save_expo.c
@@ -35,11 +35,11 @@ mpfr_save_emin_emax (void)
 {
   if (save_ctr++ == 0)
     {
-      saved_flags = __mpfr_flags;
-      saved_emin = __mpfr_emin;
-      saved_emax = __mpfr_emax;
-      __mpfr_emin = MPFR_EMIN_MIN;
-      __mpfr_emax = MPFR_EMAX_MAX;
+      saved_flags = __gmpfr_flags;
+      saved_emin = __gmpfr_emin;
+      saved_emax = __gmpfr_emax;
+      __gmpfr_emin = MPFR_EMIN_MIN;
+      __gmpfr_emax = MPFR_EMAX_MAX;
     }
   else if (save_ctr == 0)
     {
@@ -55,8 +55,8 @@ mpfr_restore_emin_emax (void)
 {
   if (--save_ctr == 0)
     {
-      __mpfr_flags |= saved_flags;
-      __mpfr_emin = saved_emin;
-      __mpfr_emax = saved_emax;
+      __gmpfr_flags |= saved_flags;
+      __gmpfr_emin = saved_emin;
+      __gmpfr_emax = saved_emax;
     }
 }
diff --git a/set.c b/set.c
index a9469b289..ce6a6c9af 100644
--- a/set.c
+++ b/set.c
@@ -68,7 +68,7 @@ mpfr_set4 (mpfr_ptr a, mpfr_srcptr b, mp_rnd_t rnd_mode, int signb)
             {
               mp_exp_t exp = MPFR_EXP(a);
 
-              if (exp == __mpfr_emax)
+              if (exp == __gmpfr_emax)
                 return mpfr_set_overflow(a, rnd_mode, signb);
 
               MPFR_EXP(a)++;
diff --git a/set_dfl_prec.c b/set_dfl_prec.c
index 69d6260c2..c61875793 100644
--- a/set_dfl_prec.c
+++ b/set_dfl_prec.c
@@ -25,17 +25,17 @@ MA 02111-1307, USA. */
 #include "mpfr-impl.h"
 
 /* default is 53 bits */
-mp_prec_t __mpfr_default_fp_bit_precision = 53;
+mp_prec_t __gmpfr_default_fp_bit_precision = 53;
 
 void
 mpfr_set_default_prec (mp_prec_t prec)
 {
   MPFR_ASSERTN(prec >= MPFR_PREC_MIN && prec <= MPFR_PREC_MAX);
-  __mpfr_default_fp_bit_precision = prec;
+  __gmpfr_default_fp_bit_precision = prec;
 }
 
 mp_prec_t
 mpfr_get_default_prec (void)
 {
-  return __mpfr_default_fp_bit_precision;
+  return __gmpfr_default_fp_bit_precision;
 }
diff --git a/set_exp.c b/set_exp.c
index 5f9e24b1d..e3793403a 100644
--- a/set_exp.c
+++ b/set_exp.c
@@ -27,7 +27,7 @@ MA 02111-1307, USA. */
 int
 mpfr_set_exp (mpfr_ptr x, mp_exp_t exponent)
 {
-  if (exponent >= __mpfr_emin && exponent <= __mpfr_emax)
+  if (exponent >= __gmpfr_emin && exponent <= __gmpfr_emax)
     {
       MPFR_EXP(x) = exponent;
       return 0;
diff --git a/set_nan.c b/set_nan.c
index bc650561a..a32694487 100644
--- a/set_nan.c
+++ b/set_nan.c
@@ -28,5 +28,5 @@ void
 mpfr_set_nan (mpfr_ptr x)
 {
   MPFR_SET_NAN (x);
-  __mpfr_flags |= MPFR_FLAGS_NAN;
+  __gmpfr_flags |= MPFR_FLAGS_NAN;
 }
diff --git a/set_rnd.c b/set_rnd.c
index a80e06166..4cb43dbdd 100644
--- a/set_rnd.c
+++ b/set_rnd.c
@@ -23,10 +23,10 @@ MA 02111-1307, USA. */
 #include "gmp-impl.h"
 #include "mpfr.h"
 
-mp_rnd_t __gmp_default_rounding_mode = 0;
+mp_rnd_t __gmpfr_default_rounding_mode = 0;
 
 void
 mpfr_set_default_rounding_mode (mp_rnd_t rnd_mode)
 {
-  __gmp_default_rounding_mode = rnd_mode;
+  __gmpfr_default_rounding_mode = rnd_mode;
 }
diff --git a/set_si.c b/set_si.c
index a6660a754..af8b4f83f 100644
--- a/set_si.c
+++ b/set_si.c
@@ -70,7 +70,7 @@ mpfr_set_si (mpfr_ptr x, long i, mp_rnd_t rnd_mode)
         {
           mp_exp_t exp = MPFR_EXP(x);
 
-          if (exp == __mpfr_emax)
+          if (exp == __gmpfr_emax)
             return mpfr_set_overflow(x, rnd_mode, (i < 0 ? -1 : 1));
 
           MPFR_EXP(x)++;
diff --git a/set_str.c b/set_str.c
index b695f6e67..9b77440cd 100644
--- a/set_str.c
+++ b/set_str.c
@@ -73,7 +73,7 @@ mpfr_set_str (mpfr_ptr x, __gmp_const char *str, int base, mp_rnd_t rnd_mode)
     {
       MPFR_SET_NAN(x);
       /* MPFR_RET_NAN not used as the return value isn't a ternary value */
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       return 3;
     }
 
diff --git a/set_str_raw.c b/set_str_raw.c
index e07099afd..b5a22dfe2 100644
--- a/set_str_raw.c
+++ b/set_str_raw.c
@@ -54,7 +54,7 @@ mpfr_set_str_raw (mpfr_ptr x, char *str)
   if (*str == 'N')
     {
       MPFR_SET_NAN(x);
-      __mpfr_flags |= MPFR_FLAGS_NAN;
+      __gmpfr_flags |= MPFR_FLAGS_NAN;
       return;
     }
 
diff --git a/set_ui.c b/set_ui.c
index a64b36677..49188522d 100644
--- a/set_ui.c
+++ b/set_ui.c
@@ -63,7 +63,7 @@ mpfr_set_ui (mpfr_ptr x, unsigned long i, mp_rnd_t rnd_mode)
             {
               mp_exp_t exp = MPFR_EXP(x);
 
-              if (exp == __mpfr_emax)
+              if (exp == __gmpfr_emax)
                 return mpfr_set_overflow(x, rnd_mode, 1);
 
               MPFR_EXP(x)++;
diff --git a/set_z.c b/set_z.c
index a60a05895..642d4452c 100644
--- a/set_z.c
+++ b/set_z.c
@@ -55,9 +55,9 @@ mpfr_set_z (mpfr_ptr f, mpz_srcptr z, mp_rnd_t rnd_mode)
 
   if (zn > MPFR_EMAX_MAX / BITS_PER_MP_LIMB + 1)
     return mpfr_set_overflow(f, rnd_mode, sign_z);
-  /* because zn >= __mpfr_emax / BITS_PER_MP_LIMB + 2
-     and zn * BITS_PER_MP_LIMB >= __mpfr_emax + BITS_PER_MP_LIMB + 1
-     and exp = zn * BITS_PER_MP_LIMB - k > __mpfr_emax */
+  /* because zn >= __gmpfr_emax / BITS_PER_MP_LIMB + 2
+     and zn * BITS_PER_MP_LIMB >= __gmpfr_emax + BITS_PER_MP_LIMB + 1
+     and exp = zn * BITS_PER_MP_LIMB - k > __gmpfr_emax */
 
   /* now zn <= MPFR_EMAX_MAX / BITS_PER_MP_LIMB + 1
      thus zn * BITS_PER_MP_LIMB <= MPFR_EMAX_MAX + BITS_PER_MP_LIMB
@@ -65,9 +65,9 @@ mpfr_set_z (mpfr_ptr f, mpz_srcptr z, mp_rnd_t rnd_mode)
              <= MPFR_EMAX_MAX + BITS_PER_MP_LIMB */
   exp = (mp_prec_t) zn * BITS_PER_MP_LIMB - k;
   /* The exponent will be exp or exp + 1 (due to rounding) */
-  if (exp > __mpfr_emax)
+  if (exp > __gmpfr_emax)
     return mpfr_set_overflow(f, rnd_mode, sign_z);
-  if (exp + 1 < __mpfr_emin)
+  if (exp + 1 < __gmpfr_emin)
     return mpfr_set_underflow(f, rnd_mode == GMP_RNDN ? GMP_RNDZ : rnd_mode,
                               sign_z);
 
@@ -150,7 +150,7 @@ mpfr_set_z (mpfr_ptr f, mpz_srcptr z, mp_rnd_t rnd_mode)
         {
           if (mpn_add_1(fp, fp, fn, MP_LIMB_T_ONE << sh))
             {
-              if (exp == __mpfr_emax)
+              if (exp == __gmpfr_emax)
                 return mpfr_set_overflow(f, rnd_mode, sign_z);
               else
                 {
@@ -172,7 +172,7 @@ mpfr_set_z (mpfr_ptr f, mpz_srcptr z, mp_rnd_t rnd_mode)
       inex = 0; /* result is exact */
     }
 
-  if (exp < __mpfr_emin)
+  if (exp < __gmpfr_emin)
     {
       if (rnd_mode == GMP_RNDN && inex == 0 && mpfr_powerof2_raw (f))
         rnd_mode = GMP_RNDZ;
diff --git a/sin.c b/sin.c
index 60bf08ea6..79e7fce49 100644
--- a/sin.c
+++ b/sin.c
@@ -107,7 +107,7 @@ mpfr_sin (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
     }
 
   precy = MPFR_PREC(y);
-  m = precy + _mpfr_ceil_log2 ((double) precy) + MAX(0,MPFR_EXP(x)) + 13;
+  m = precy + __gmpfr_ceil_log2 ((double) precy) + MAX(0,MPFR_EXP(x)) + 13;
   
   sign = mpfr_sin_sign (x);
 
diff --git a/sin_cos.c b/sin_cos.c
index 93968cf1f..9b6c23993 100644
--- a/sin_cos.c
+++ b/sin_cos.c
@@ -48,7 +48,7 @@ mpfr_sin_cos (mpfr_ptr y, mpfr_ptr z, mpfr_srcptr x, mp_rnd_t rnd_mode)
     }
 
   prec = MAX(MPFR_PREC(y), MPFR_PREC(z));
-  m = prec + _mpfr_ceil_log2 ((double) prec) + ABS(MPFR_EXP(x)) + 13;
+  m = prec + __gmpfr_ceil_log2 ((double) prec) + ABS(MPFR_EXP(x)) + 13;
 
   mpfr_init2 (c, m);
   mpfr_init2 (k, m);
@@ -85,7 +85,7 @@ mpfr_sin_cos (mpfr_ptr y, mpfr_ptr z, mpfr_srcptr x, mp_rnd_t rnd_mode)
 
       if (ok == 0)
 	{
-	  m += _mpfr_ceil_log2 ((double) m);
+	  m += __gmpfr_ceil_log2 ((double) m);
 	  mpfr_set_prec (c, m);
 	}
     }
diff --git a/sinh.c b/sinh.c
index dceaf14c7..7be49ebba 100644
--- a/sinh.c
+++ b/sinh.c
@@ -86,7 +86,7 @@ mpfr_sinh (mpfr_ptr y, mpfr_srcptr xt, mp_rnd_t rnd_mode)
       /* compute the precision of intermediary variable */
       Nt = MAX(Nx, Ny);
       /* the optimal number of bits : see algorithms.ps */
-      Nt = Nt + _mpfr_ceil_log2 (5) + _mpfr_ceil_log2 (Nt);
+      Nt = Nt + __gmpfr_ceil_log2 (5) + __gmpfr_ceil_log2 (Nt);
 
       /* initialise of intermediary	variable */
       mpfr_init (t);
@@ -119,7 +119,7 @@ mpfr_sinh (mpfr_ptr y, mpfr_srcptr xt, mp_rnd_t rnd_mode)
             d = MPFR_EXP(te) - MPFR_EXP(t) + 2;
 	
             /* estimation of the error */
-            /* err = Nt-(_mpfr_ceil_log2(1+pow(2,d)));*/
+            /* err = Nt-(__gmpfr_ceil_log2(1+pow(2,d)));*/
             err = Nt - (MAX(d,0) + 1);
           }
 
diff --git a/sub1.c b/sub1.c
index 0365173e1..a97d03a95 100644
--- a/sub1.c
+++ b/sub1.c
@@ -394,11 +394,11 @@ mpfr_sub1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode,
 
       cancel -= add_exp; /* still valid as unsigned long */
       exp_a = MPFR_EXP(b) - cancel;
-      if (exp_a < __mpfr_emin)
+      if (exp_a < __gmpfr_emin)
         {
           TMP_FREE(marker);
           if (rnd_mode == GMP_RNDN &&
-              (exp_a < __mpfr_emin - 1 ||
+              (exp_a < __gmpfr_emin - 1 ||
                (inexact >= 0 && mpfr_powerof2_raw (a))))
             rnd_mode = GMP_RNDZ;
           return mpfr_set_underflow (a, rnd_mode, MPFR_SIGN(a));
@@ -410,7 +410,7 @@ mpfr_sub1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode,
       /* in case cancel = 0, add_exp can still be 1, in case b is just
 	 below a power of two, c is very small, prec(a) < prec(b),
 	 and rnd=away or nearest */
-      if (add_exp && MPFR_EXP(b) == __mpfr_emax)
+      if (add_exp && MPFR_EXP(b) == __gmpfr_emax)
 	{
 	  TMP_FREE(marker);
 	  return mpfr_set_overflow (a, rnd_mode, MPFR_SIGN(a));
diff --git a/sub_one_ulp.c b/sub_one_ulp.c
index 323ab4fd1..a14b35867 100644
--- a/sub_one_ulp.c
+++ b/sub_one_ulp.c
@@ -49,7 +49,7 @@ mpfr_sub_one_ulp(mpfr_ptr x, mp_rnd_t rnd_mode)
       mp_exp_t exp = MPFR_EXP(x);
       /* Note: In case of underflow and rounding to the nearest mode,
          x won't be changed. Beware of infinite loops! */
-      if (exp == __mpfr_emin)
+      if (exp == __gmpfr_emin)
         return mpfr_set_underflow(x, rnd_mode, MPFR_SIGN(x));
       else
         {
diff --git a/tan.c b/tan.c
index 374a2fe12..091737ae2 100644
--- a/tan.c
+++ b/tan.c
@@ -46,7 +46,7 @@ mpfr_tan (mpfr_ptr y, mpfr_srcptr x, mp_rnd_t rnd_mode)
     }
 
   precy = MPFR_PREC(y);
-  m = precy + _mpfr_ceil_log2 ((double) precy) + ABS(MPFR_EXP(x)) + 13;
+  m = precy + __gmpfr_ceil_log2 ((double) precy) + ABS(MPFR_EXP(x)) + 13;
 
   mpfr_init2 (s, m);
   mpfr_init2 (c, m);
diff --git a/tanh.c b/tanh.c
index b818ab4e2..6cc4195cd 100644
--- a/tanh.c
+++ b/tanh.c
@@ -96,7 +96,7 @@ mpfr_tanh (y, xt, rnd_mode)
       /* compute the precision of intermediary variable */
       Nt=MAX(Nx,Ny);
       /* the optimal number of bits : see algorithms.ps */
-      Nt = Nt+_mpfr_ceil_log2(9)+_mpfr_ceil_log2(Nt);
+      Nt = Nt+__gmpfr_ceil_log2(9)+__gmpfr_ceil_log2(Nt);
 
       /* initialise of intermediary	variable */
       mpfr_init(t); 
@@ -126,7 +126,7 @@ mpfr_tanh (y, xt, rnd_mode)
         d = MPFR_EXP(te)-MPFR_EXP(t);
 	
 	/* estimation of the error */
-        /*err = Nt-(_mpfr_ceil_log2(7+pow(2,d+1)));*/
+        /*err = Nt-(__gmpfr_ceil_log2(7+pow(2,d+1)));*/
         err = Nt-(MAX(d+1,3)+1);
 
 	/* actualisation of the precision */
diff --git a/tests/tconst_log2.c b/tests/tconst_log2.c
index 04817d691..43b577ea0 100644
--- a/tests/tconst_log2.c
+++ b/tests/tconst_log2.c
@@ -41,7 +41,7 @@ check (mp_prec_t p0, mp_prec_t p1)
   mpfr_init (y);
   mpfr_init2 (z, p1 + 10);
   mpfr_const_log2 (z, GMP_RNDN);
-  __mpfr_const_log2_prec = 1;
+  __gmpfr_const_log2_prec = 1;
 
   for (; p0<=p1; p0++)
     {
diff --git a/tests/tests.c b/tests/tests.c
index 5b143d9fb..9419e21d9 100644
--- a/tests/tests.c
+++ b/tests/tests.c
@@ -37,16 +37,16 @@ tests_start_mpfr (void)
 void
 tests_end_mpfr (void)
 {
-  if (__mpfr_const_pi_prec != 0)
+  if (__gmpfr_const_pi_prec != 0)
     {
       mpfr_clear (__mpfr_const_pi);
-      __mpfr_const_pi_prec = 0;
+      __gmpfr_const_pi_prec = 0;
     }
 
-  if (__mpfr_const_log2_prec != 0)
+  if (__gmpfr_const_log2_prec != 0)
     {
       mpfr_clear (__mpfr_const_log2);
-      __mpfr_const_log2_prec = 0;
+      __gmpfr_const_log2_prec = 0;
     }
 
   if (__gmp_rands_initialized)
diff --git a/uceil_exp2.c b/uceil_exp2.c
index 231369f38..8003a5164 100644
--- a/uceil_exp2.c
+++ b/uceil_exp2.c
@@ -1,4 +1,4 @@
-/* _mpfr_ceil_exp2 - returns y >= 2^d
+/* __gmpfr_ceil_exp2 - returns y >= 2^d
 
 Copyright 1999, 2000, 2001, 2002 Free Software Foundation.
 
@@ -26,7 +26,7 @@ MA 02111-1307, USA. */
 
 /* returns y >= 2^d, assuming that d <= 1024 */
 double
-_mpfr_ceil_exp2 (double d)
+__gmpfr_ceil_exp2 (double d)
 {
   long exp;
   union ieee_double_extract x;
diff --git a/uceil_log2.c b/uceil_log2.c
index 9decc009f..f7ba603cd 100644
--- a/uceil_log2.c
+++ b/uceil_log2.c
@@ -1,4 +1,4 @@
-/* _mpfr_ceil_log2 - returns ceil(log(d)/log(2))
+/* __gmpfr_ceil_log2 - returns ceil(log(d)/log(2))
 
 Copyright 1999, 2000, 2001, 2002 Free Software Foundation.
 
@@ -26,7 +26,7 @@ MA 02111-1307, USA. */
 
 /* returns ceil(log(d)/log(2)) */
 long
-_mpfr_ceil_log2 (double d)
+__gmpfr_ceil_log2 (double d)
 {
   long exp;
   union ieee_double_extract x;
diff --git a/ufloor_log2.c b/ufloor_log2.c
index 48ee49283..7d8e05494 100644
--- a/ufloor_log2.c
+++ b/ufloor_log2.c
@@ -1,4 +1,4 @@
-/* _mpfr_floor_log2 - returns floor(log(d)/log(2))
+/* __gmpfr_floor_log2 - returns floor(log(d)/log(2))
 
 Copyright 1999, 2000, 2001, 2002 Free Software Foundation.
 
@@ -26,7 +26,7 @@ MA 02111-1307, USA. */
 
 /* returns floor(log(d)/log(2)) */
 long
-_mpfr_floor_log2 (double d)
+__gmpfr_floor_log2 (double d)
 {
   union ieee_double_extract x;
 
diff --git a/ui_pow.c b/ui_pow.c
index 275eb5b2d..d1364f41e 100644
--- a/ui_pow.c
+++ b/ui_pow.c
@@ -141,7 +141,7 @@ mpfr_ui_pow (mpfr_ptr y, unsigned long int n, mpfr_srcptr x, mp_rnd_t rnd_mode)
       /* compute the precision of intermediary variable */
       Nt = MAX(Nx,Ny);
       /* the optimal number of bits : see algorithms.ps */
-      Nt = Nt + 5 + _mpfr_ceil_log2 (Nt);
+      Nt = Nt + 5 + __gmpfr_ceil_log2 (Nt);
 
       /* initialise of intermediary	variable */
       mpfr_init2 (t, MPFR_PREC_MIN);