Change the internal format of MPFR: ZERO, INF and NAN have special values of exp.

Rename MPFR_ESIZE in MPFR_LIMB_SIZE.
Rename MPFR_ABSZISE in MPFR_ALLOC_SIZE.
Rename MPFR_INIT in MPFR_TMP_INIT (INIT1 too).
"mpfr.h" includes <gmp.h> if GMP isn't detected.
Change the way of detecting stdio.h (To check).
Use mpfr namespace for new definitions in "mpfr.h".


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

28 files changed, 383 insertions, 320 deletions

diff --git a/add.c b/add.c
index 3f4ee6710..8bf4bcc9a 100644
--- a/add.c
+++ b/add.c
@@ -64,13 +64,10 @@ mpfr_add (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode)
     {
       if (MPFR_IS_ZERO(c))
         {
-          if (MPFR_SIGN(a) !=
-              (rnd_mode != GMP_RNDD ?
-               ((MPFR_SIGN(b) < 0 && MPFR_SIGN(c) < 0) ? -1 : 1) :
-               ((MPFR_SIGN(b) > 0 && MPFR_SIGN(c) > 0) ? 1 : -1)))
-            {
-              MPFR_CHANGE_SIGN(a);
-            }
+	  MPFR_SET_SIGN(a,
+			(rnd_mode != GMP_RNDD ?
+			 ((MPFR_SIGN(b) < 0 && MPFR_SIGN(c) < 0) ? -1 : 1) :
+			 ((MPFR_SIGN(b) > 0 && MPFR_SIGN(c) > 0) ? 1 : -1)));
           MPFR_CLEAR_INF(a);
           MPFR_SET_ZERO(a);
           MPFR_RET(0); /* 0 + 0 is exact */
diff --git a/add_ui.c b/add_ui.c
index a0dc2912c..a4b737f97 100644
--- a/add_ui.c
+++ b/add_ui.c
@@ -35,7 +35,7 @@ mpfr_add_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mp_rnd_t rnd_mode)
       unsigned long cnt;
       int inex;
 
-      MPFR_INIT1(up, uu, BITS_PER_MP_LIMB, 1);
+      MPFR_TMP_INIT1(up, uu, BITS_PER_MP_LIMB);
       MPFR_ASSERTN(u == (mp_limb_t) u);
       count_leading_zeros(cnt, (mp_limb_t) u);
       *up = (mp_limb_t) u << cnt;
diff --git a/agm.c b/agm.c
index f96c8340b..750ad3e9d 100644
--- a/agm.c
+++ b/agm.c
@@ -78,15 +78,13 @@ mpfr_agm (mpfr_ptr r, mpfr_srcptr op2, mpfr_srcptr op1, mp_rnd_t rnd_mode)
  
   TMP_MARK(marker);
   s=(p-1)/BITS_PER_MP_LIMB+1;
-  MPFR_INIT(ap, a, p, s);  
-  MPFR_INIT(bp, b, p, s);
-  MPFR_INIT(up, u, p, s);
-  MPFR_INIT(vp, v, p, s);   
-  MPFR_INIT(tmpup, tmpu, p, s);  
-  MPFR_INIT(tmpvp, tmpv, p, s);  
-  MPFR_INIT(tmpp, tmp, p, s);  
-
-
+  MPFR_TMP_INIT(ap, a, p, s);  
+  MPFR_TMP_INIT(bp, b, p, s);
+  MPFR_TMP_INIT(up, u, p, s);
+  MPFR_TMP_INIT(vp, v, p, s);   
+  MPFR_TMP_INIT(tmpup, tmpu, p, s);
+  MPFR_TMP_INIT(tmpvp, tmpv, p, s);
+  MPFR_TMP_INIT(tmpp, tmp, p, s);
 
   /* b and a are the 2 operands but we want b >= a */
   if ((compare = mpfr_cmp (op1,op2)) > 0)
@@ -155,11 +153,11 @@ mpfr_agm (mpfr_ptr r, mpfr_srcptr op2, mpfr_srcptr op1, mp_rnd_t rnd_mode)
 	  go_on = 1;
 	  p+=5;
 	  s=(p-1)/BITS_PER_MP_LIMB+1;
-	  MPFR_INIT(up, u, p, s);
-	  MPFR_INIT(vp, v, p, s);   
-	  MPFR_INIT(tmpup, tmpu, p, s);  
-	  MPFR_INIT(tmpvp, tmpv, p, s);  
-	  MPFR_INIT(tmpp, tmp, p, s);
+	  MPFR_TMP_INIT(up, u, p, s);
+	  MPFR_TMP_INIT(vp, v, p, s);   
+	  MPFR_TMP_INIT(tmpup, tmpu, p, s);  
+	  MPFR_TMP_INIT(tmpvp, tmpv, p, s);  
+	  MPFR_TMP_INIT(tmpp, tmp, p, s);
 	  mpfr_set(u,a,GMP_RNDN);
 	  mpfr_set(v,b,GMP_RNDN);
       }
diff --git a/clear.c b/clear.c
index 09516b4da..dbfbde078 100644
--- a/clear.c
+++ b/clear.c
@@ -29,5 +29,6 @@ void
 mpfr_clear (mpfr_ptr m)
 {
   /* be careful to always free an entire number of limbs */
-  (*__gmp_free_func) (MPFR_MANT(m), MPFR_ABSSIZE(m) * BYTES_PER_MP_LIMB);
+  (*__gmp_free_func) 
+    (MPFR_GET_REAL_PTR(m), MPFR_ALLOC_SIZE(MPFR_GET_ALLOC_SIZE(m)));
 }
diff --git a/div.c b/div.c
index 9c0e119e3..aaa8f176a 100644
--- a/div.c
+++ b/div.c
@@ -117,8 +117,8 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mp_rnd_t rnd_mode)
   vp = MPFR_MANT(v);
 
   TMP_MARK (marker);
-  usize = MPFR_ESIZE(u); 
-  vsize = MPFR_ESIZE(v); 
+  usize = MPFR_LIMB_SIZE(u); 
+  vsize = MPFR_LIMB_SIZE(v); 
 
   /**************************************************************************
    *                                                                        *
@@ -355,8 +355,8 @@ mpfr_div (mpfr_ptr q, mpfr_srcptr u, mpfr_srcptr v, mp_rnd_t rnd_mode)
   cc = mpfr_round_raw_generic(qp, qp, err, (sign_quotient == -1 ? 1 : 0),
 			      MPFR_PREC(q), rnd_mode, &inex, 1);      
 
-  qp += qsize - MPFR_ESIZE(q); /* 0 or 1 */
-  qsize = MPFR_ESIZE(q); 
+  qp += qsize - MPFR_LIMB_SIZE(q); /* 0 or 1 */
+  qsize = MPFR_LIMB_SIZE(q); 
 
   /* 
      At that point, either we were able to round from the beginning, 
diff --git a/exceptions.c b/exceptions.c
index ca3172a00..2469236cc 100644
--- a/exceptions.c
+++ b/exceptions.c
@@ -204,8 +204,7 @@ mpfr_set_underflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
       MPFR_SET_ZERO(x);
       inex = -1;
     }
-  if (MPFR_SIGN(x) != sign)
-    MPFR_CHANGE_SIGN(x);
+  MPFR_SET_SIGN(x, sign);
   __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_UNDERFLOW;
   return sign > 0 ? inex : -inex;
 }
@@ -230,8 +229,7 @@ mpfr_set_overflow (mpfr_ptr x, mp_rnd_t rnd_mode, int sign)
       mpfr_setmax (x, __gmpfr_emax);
       inex = -1;
     }
-  if (MPFR_SIGN(x) != sign)
-    MPFR_CHANGE_SIGN(x);
+  MPFR_SET_SIGN(x,sign);
   __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_OVERFLOW;
   return sign > 0 ? inex : -inex;
 }
diff --git a/extract.c b/extract.c
index b2e43f4fa..6401ddd67 100644
--- a/extract.c
+++ b/extract.c
@@ -38,7 +38,7 @@ mpfr_extract (mpz_ptr y, mpfr_srcptr p, unsigned int i)
 {
   int two_i = 1 << i;
   int two_i_2 = i ? two_i / 2 : 1;
-  mp_size_t size_p = MPFR_ESIZE(p);
+  mp_size_t size_p = MPFR_LIMB_SIZE(p);
 
   /* as 0 <= |p| < 1, we don't have to care with infinities, NaN, ... */
   
diff --git a/get_d.c b/get_d.c
index 85590c0bb..5bd2851e7 100644
--- a/get_d.c
+++ b/get_d.c
@@ -201,7 +201,7 @@ mpfr_get_d3 (mpfr_srcptr src, mp_exp_t e, mp_rnd_t rnd_mode)
           MPFR_ASSERTN(nbits >= 1);
         }
       np = (nbits - 1) / BITS_PER_MP_LIMB;
-      tp = (mp_ptr) (*__gmp_allocate_func) ((np + 1) * BYTES_PER_MP_LIMB);
+      tp = (mp_ptr) (*__gmp_allocate_func)((np+1) * BYTES_PER_MP_LIMB);
       carry = mpfr_round_raw (tp, MPFR_MANT(src), MPFR_PREC(src), negative,
                              nbits, rnd_mode, (int *) 0);
       if (carry)
diff --git a/get_si.c b/get_si.c
index cf7535abe..68c4aecb8 100644
--- a/get_si.c
+++ b/get_si.c
@@ -48,7 +48,7 @@ mpfr_get_si (mpfr_srcptr f, mp_rnd_t rnd)
 
   /* now the result is in the most significant limb of x */
   exp = MPFR_GET_EXP (x); /* since |x| >= 1, exp >= 1 */
-  n = MPFR_ESIZE(x);
+  n = MPFR_LIMB_SIZE(x);
   s = MPFR_MANT(x)[n - 1] >> (GMP_NUMB_BITS - exp);
 
   mpfr_clear (x);
diff --git a/get_str.c b/get_str.c
index fceaa066b..f66c9c00f 100644
--- a/get_str.c
+++ b/get_str.c
@@ -595,8 +595,12 @@ mpfr_get_str (char *s, mp_exp_t *e, int b, size_t m, mpfr_srcptr x, mp_rnd_t rnd
     {
       switch (rnd)
 	{
-	case GMP_RNDU : rnd = GMP_RNDD; break;
-	case GMP_RNDD : rnd = GMP_RNDU; break;
+	case GMP_RNDU :
+	  rnd = GMP_RNDD; break;
+	case GMP_RNDD :
+	  rnd = GMP_RNDU; break;
+	default:
+	  break;
 	}
     }
 
diff --git a/get_ui.c b/get_ui.c
index 90239bab9..7268a6d67 100644
--- a/get_ui.c
+++ b/get_ui.c
@@ -48,7 +48,7 @@ mpfr_get_ui (mpfr_srcptr f, mp_rnd_t rnd)
 
   /* now the result is in the most significant limb of x */
   exp = MPFR_GET_EXP (x); /* since |x| >= 1, exp >= 1 */
-  n = MPFR_ESIZE(x);
+  n = MPFR_LIMB_SIZE(x);
   s = MPFR_MANT(x)[n - 1] >> (GMP_NUMB_BITS - exp);
 
   mpfr_clear (x);
diff --git a/init2.c b/init2.c
index fd76177a5..676f7daff 100644
--- a/init2.c
+++ b/init2.c
@@ -26,9 +26,10 @@ MA 02111-1307, USA. */
 #include "mpfr-impl.h"
 
 void
-mpfr_init2 (mpfr_ptr x, mp_prec_t p)
+mpfr_init2 (mpfr_ptr x, mpfr_prec_t p)
 {
-  mp_size_t xsize;
+  mpfr_size_t xsize;
+  mp_ptr tmp;
 
   /* p=1 is not allowed since the rounding to nearest even rule requires at
      least two bits of mantissa: the neighbours of 3/2 are 1*2^0 and 1*2^1,
@@ -36,10 +37,11 @@ mpfr_init2 (mpfr_ptr x, mp_prec_t p)
   MPFR_ASSERTN(p >= MPFR_PREC_MIN && p <= MPFR_PREC_MAX);
 
   xsize = (mp_size_t) ((p - 1) / BITS_PER_MP_LIMB) + 1;
-
+  tmp   = (mp_ptr) (*__gmp_allocate_func)(MPFR_ALLOC_SIZE(xsize));
+  
   MPFR_PREC(x) = p;
-  MPFR_MANT(x) = (mp_ptr)
-    (*__gmp_allocate_func) ((size_t) xsize * BYTES_PER_MP_LIMB);
-  MPFR_SIZE(x) = xsize;
+  MPFR_SET_POS(x);   /* Set a sign */
+  MPFR_SET_MANT_PTR(x, tmp);
+  MPFR_SET_ALLOC_SIZE(x, xsize);
   MPFR_SET_NAN(x); /* initializes to NaN */
 }
diff --git a/log.c b/log.c
index 9904ab08f..f92eca156 100644
--- a/log.c
+++ b/log.c
@@ -126,13 +126,13 @@ mpfr_log (mpfr_ptr r, mpfr_srcptr a, mp_rnd_t rnd_mode)
     /* All the mpfr_t needed have a precision of p */
     TMP_MARK(marker);
     size=(p-1)/BITS_PER_MP_LIMB+1;
-    MPFR_INIT(cstp, cst, p, size);  
-    MPFR_INIT(rapportp, rapport, p, size);
-    MPFR_INIT(agmp, agm, p, size);
-    MPFR_INIT(tmp1p, tmp1, p, size);  
-    MPFR_INIT(tmp2p, tmp2, p, size);  
-    MPFR_INIT(sp, s, p, size);
-    MPFR_INIT(mmp, mm, p, size);
+    MPFR_TMP_INIT(cstp, cst, p, size);  
+    MPFR_TMP_INIT(rapportp, rapport, p, size);
+    MPFR_TMP_INIT(agmp, agm, p, size);
+    MPFR_TMP_INIT(tmp1p, tmp1, p, size);  
+    MPFR_TMP_INIT(tmp2p, tmp2, p, size);  
+    MPFR_TMP_INIT(sp, s, p, size);
+    MPFR_TMP_INIT(mmp, mm, p, size);
 
     mpfr_set_si (mm, m, GMP_RNDN);        /* I have m, supposed exact */
     mpfr_set_si (tmp1, 1, GMP_RNDN);      /* I have 1, exact */
diff --git a/mpfr-impl.h b/mpfr-impl.h
index e1a1b9450..9f1e8380f 100644
--- a/mpfr-impl.h
+++ b/mpfr-impl.h
@@ -19,6 +19,14 @@ along with the MPFR Library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 MA 02111-1307, USA. */
 
+/* Auto include local mpfr.h if not included */
+#ifndef __MPFR_H
+#include "mpfr.h"
+#endif
+
+/* Auto-include limits.h */
+#include <limits.h>
+
 #ifndef HAVE_STRCASECMP
 #define strcasecmp mpfr_strcasecmp
 #endif
@@ -39,13 +47,26 @@ MA 02111-1307, USA. */
 #error "MPFR doesn't support nonzero values of GMP_NAIL_BITS"
 #endif
 
-/* Test if X (positive) is a power of 2 */
+#if (BITS_PER_MP_LIMB & (BITS_PER_MP_LIMB - 1))
+#error "BITS_PER_MP_LIMB must be a power of 2"
+#endif
 
+/* Test if X (positive) is a power of 2 */
 #define IS_POW2(X) (((X) & ((X) - 1)) == 0)
 #define NOT_POW2(X) (((X) & ((X) - 1)) != 0)
 
+/* Update Exp limits */
+#ifdef  MPFR_EXP_FORMAT_INT
+# define MPFR_EXP_MAX (INT_MAX)
+# define MPFR_EXP_MIN (INT_MIN)
+#else
+# define MPFR_EXP_MAX (LONG_MAX)
+# define MPFR_EXP_MIN (LONG_MIN)
+#endif
+
 /* This unsigned type must correspond to the signed one defined in gmp.h */
-#if defined (_CRAY) && ! defined (_CRAYMPP)
+/* FIXME: Useless since EXP < MAX/2? Remove?*/
+#ifdef MPFR_EXP_FORMAT_INT
 typedef unsigned int            mp_exp_unsigned_t;
 typedef unsigned int            mp_size_unsigned_t;
 #else
@@ -53,15 +74,13 @@ typedef unsigned long int       mp_exp_unsigned_t;
 typedef unsigned long int       mp_size_unsigned_t;
 #endif
 
-#define MP_EXP_T_MAX ((mp_exp_t) ((~ (mp_exp_unsigned_t) 0) >> 1))
+#define MP_EXP_T_MAX MPFR_EXP_MAX
+/* FIXME: Is this really portable? */
+/*#define MP_EXP_T_MAX ((mp_exp_t) ((~ (mp_exp_unsigned_t) 0) >> 1))*/
 #define MP_EXP_T_MIN (-MP_EXP_T_MAX-1)
 
 #define MP_LIMB_T_ONE ((mp_limb_t) 1)
 
-#if (BITS_PER_MP_LIMB & (BITS_PER_MP_LIMB - 1))
-#error "BITS_PER_MP_LIMB must be a power of 2"
-#endif
-
 #define MPFR_INTPREC_MAX (ULONG_MAX & ~(unsigned long) (BITS_PER_MP_LIMB - 1))
 
 /* Assertions */
@@ -85,6 +104,16 @@ typedef unsigned long int       mp_size_unsigned_t;
 #define MPFR_ASSERTD(expr)  ((void) 0)
 #endif
 
+/* Theses macros help the compiler to determine if a test is likely*/
+/* or unlikely. */
+#if __GNUC__ >= 3
+#define MPFR_LIKELY(x) (__builtin_expect(!!(x),1))
+#define MPFR_UNLIKELY(x) (__builtin_expect((x),0))
+#else
+#define MPFR_LIKELY(x) (x)
+#define MPFR_UNLIKELY(x) (x)
+#endif
+
 /* Invalid exponent value (to track bugs...) */
 #define MPFR_EXP_INVALID ((mp_exp_t) 1 << 30)
 
@@ -207,51 +236,58 @@ long double __gmpfr_longdouble_volatile __GMP_PROTO ((long double)) ATTRIBUTE_CO
 #endif
 #endif
 
+/* Warning: Pb if non 2 comp representaiton as C standard allows */
+/* Definition of the special values of the exponent */
+/* Clear flags macros are still defined and should be still used */
+/* since functions shouldn't rely on a specific format */
 
-/* bit 31 of _mpfr_size is used for sign,
-   bit 30 of _mpfr_size is used for Nan flag,
-   bit 29 of _mpfr_size is used for Inf flag,
-   remaining bits are used to store the number of allocated limbs */
-#define MPFR_CLEAR_FLAGS(x) \
-  (((x) -> _mpfr_size &= ~((mp_size_unsigned_t) 3 << 29)))
-#define MPFR_IS_NAN(x) (((x)->_mpfr_size) & ((mp_size_unsigned_t) 1 << 30))
-#define MPFR_SET_NAN(x) \
-  (MPFR_SET_INVALID_EXP(x), \
-   (x)->_mpfr_size |= ((mp_size_unsigned_t) 1 << 30))
-#define MPFR_CLEAR_NAN(x) \
-  (((x) -> _mpfr_size &= ~((mp_size_unsigned_t) 1 << 30)))
-#define MPFR_IS_INF(x) (((x)->_mpfr_size) & ((mp_size_unsigned_t) 1 << 29))
-#define MPFR_SET_INF(x) \
-  (MPFR_SET_INVALID_EXP(x), \
-   (x)->_mpfr_size |= ((mp_size_unsigned_t) 1 << 29))
-#define MPFR_CLEAR_INF(x) ((x)->_mpfr_size &= ~((mp_size_unsigned_t) 1 << 29))
-#define MPFR_IS_FP(x) \
-  ((((x) -> _mpfr_size) & ((mp_size_unsigned_t) 3 << 29)) == 0)
-#define MPFR_ABSSIZE(x) \
-  ((x)->_mpfr_size & (((mp_size_unsigned_t) 1 << 29) - 1))
-#define MPFR_SET_ABSSIZE(x, n) \
-  ((x)->_mpfr_size = ((x)->_mpfr_size & ((mp_size_unsigned_t) 7 << 29)) \
-                     | (mp_size_unsigned_t) (n))
-#define MPFR_SIZE(x) ((x)->_mpfr_size)
+#define MPFR_PREC(x) ((x)->_mpfr_prec)
 #define MPFR_EXP(x) ((x)->_mpfr_exp)
 #define MPFR_MANT(x) ((x)->_mpfr_d)
-#define MPFR_ISNONNEG(x) (MPFR_NOTZERO((x)) && MPFR_SIGN(x) >= 0)
-#define MPFR_ISNEG(x) (MPFR_NOTZERO((x)) && MPFR_SIGN(x) == -1)
-#define MPFR_SET_POS(x) (MPFR_SIZE(x) &= ~(((mp_size_unsigned_t) 1) << 31))
-#define MPFR_SET_NEG(x) (MPFR_SIZE(x) |= (((mp_size_unsigned_t) 1) << 31))
-#define MPFR_CHANGE_SIGN(x) (MPFR_SIZE(x) ^= (((mp_size_unsigned_t) 1) << 31))
-#define MPFR_SET_SAME_SIGN(x, y) \
-  (MPFR_SIGN((x)) != MPFR_SIGN((y)) && (MPFR_CHANGE_SIGN((x)), 0))
-#define MPFR_PREC(x) ((x)->_mpfr_prec)
-#define MPFR_NOTZERO(x) \
-  (MPFR_MANT(x)[(MPFR_PREC(x)-1)/BITS_PER_MP_LIMB] != (mp_limb_t) 0)
-#define MPFR_IS_ZERO(x) \
-  (MPFR_MANT(x)[(MPFR_PREC(x)-1)/BITS_PER_MP_LIMB] == (mp_limb_t) 0)
-#define MPFR_SET_ZERO(x) \
-  (MPFR_SET_INVALID_EXP(x), \
-   MPFR_MANT(x)[(MPFR_PREC(x)-1)/BITS_PER_MP_LIMB] = (mp_limb_t) 0)
-#define MPFR_ESIZE(x) \
-  ((MPFR_PREC((x)) - 1) / BITS_PER_MP_LIMB + 1)
+
+/* Old ESIZE */
+#define MPFR_LIMB_SIZE(x) ((MPFR_PREC((x)) - 1) / BITS_PER_MP_LIMB + 1)
+
+#define MPFR_EXP_ZERO (MPFR_EXP_MIN+0xB)
+#define MPFR_EXP_NAN  (MPFR_EXP_MIN+0xD)
+#define MPFR_EXP_INF  (MPFR_EXP_MIN+0xE)
+
+#define MPFR_SIGN_POS (1)
+#define MPFR_SIGN_NEG (-1)
+
+#define MPFR_CLEAR_FLAGS(x)
+#define MPFR_CLEAR_NAN(x)
+#define MPFR_CLEAR_INF(x)
+
+#define MPFR_IS_NAN(x)   (MPFR_EXP(x) == MPFR_EXP_NAN)
+#define MPFR_SET_NAN(x)  (MPFR_EXP(x) =  MPFR_EXP_NAN)
+#define MPFR_IS_INF(x)   (MPFR_EXP(x) == MPFR_EXP_INF)
+#define MPFR_SET_INF(x)  (MPFR_EXP(x) =  MPFR_EXP_INF)
+#define MPFR_IS_ZERO(x)  (MPFR_EXP(x) == MPFR_EXP_ZERO)
+#define MPFR_SET_ZERO(x) (MPFR_EXP(x) =  MPFR_EXP_ZERO)
+#define MPFR_NOTZERO(x)  (MPFR_EXP(x) != MPFR_EXP_ZERO)
+
+#define MPFR_IS_FP(x)       (!MPFR_IS_NAN(x) && !MPFR_IS_INF(x))
+#define MPFR_IS_SINGULAR(x) (MPFR_EXP(x) <= MPFR_EXP_INF)
+#define MPFR_IS_REAL_FP(x)  (!MPFR_IS_SINGULAR(x))
+
+/* FIXME: NOTZERO real usefull ? */
+#define MPFR_ISNONNEG(x)  (MPFR_NOTZERO((x)) && MPFR_SIGN(x) > 0)
+#define MPFR_ISNEG(x)     (MPFR_NOTZERO((x)) && MPFR_SIGN(x) < 0)
+
+#define MPFR_SET_POS(x) (MPFR_SIGN(x) = MPFR_SIGN_POS)
+#define MPFR_SET_NEG(x) (MPFR_SIGN(x) = MPFR_SIGN_NEG)
+
+#define MPFR_CHANGE_SIGN(x) (MPFR_SIGN(x) = -MPFR_SIGN(x))
+#define MPFR_SET_SAME_SIGN(x, y) (MPFR_SIGN(x) = MPFR_SIGN(y))
+#define MPFR_CHECK_SIGN(s) \
+ (MPFR_ASSERTD((s) == MPFR_SIGN_POS || (s) == MPFR_SIGN_NEG))
+#define MPFR_SET_SIGN(x, s) \
+  (MPFR_CHECK_SIGN(s), MPFR_SIGN(x) = s)
+#define MPFR_MULT_SIGN(x, s) \
+  (MPFR_CHECK_SIGN(s), MPFR_SIGN(x) *= s)
+
+/* Special inexact value */
 #define MPFR_EVEN_INEX 2
 
 /* When returning the ternary inexact value, ALWAYS use one of the
@@ -261,18 +297,29 @@ long double __gmpfr_longdouble_volatile __GMP_PROTO ((long double)) ATTRIBUTE_CO
   (I) ? ((__gmpfr_flags |= MPFR_FLAGS_INEXACT), (I)) : 0
 #define MPFR_RET_NAN return (__gmpfr_flags |= MPFR_FLAGS_NAN), 0
 
-/* Memory gestion */
-
-/* temporary allocate s limbs at xp, and initialize mpfr variable x */
-#define MPFR_INIT(xp, x, p, s) \
-  (xp = (mp_ptr) TMP_ALLOC((size_t) (s) * BYTES_PER_MP_LIMB), \
-   MPFR_PREC(x) = (p), \
+/* Heap Memory gestion */ /* Old ABSSIZE */
+#define MPFR_GET_ALLOC_SIZE(x) ( ((mpfr_size_t*) MPFR_MANT(x))[-1] + 0)
+#define MPFR_SET_ALLOC_SIZE(x, n) ( ((mpfr_size_t*) MPFR_MANT(x))[-1] = n)
+#define MPFR_ALLOC_SIZE(s) \
+  ((size_t) (sizeof(mpfr_size_t) + BYTES_PER_MP_LIMB*(s)))
+#define MPFR_SET_MANT_PTR(x,p) \
+   (MPFR_MANT(x) = (mp_limb_t*) ((mpfr_size_t*) p + 1))
+#define MPFR_GET_REAL_PTR(x) \
+   ((mp_limb_t*) ((mpfr_size_t*) MPFR_MANT(x) - 1))
+
+/* Temporary memory gestion */
+/* temporary allocate 1 limb at xp, and initialize mpfr variable x */
+/* The temporary var doesn't have any size field, but it doesn't matter
+ * since only functions dealing with malloc care about it */
+#define MPFR_TMP_INIT1(xp, x, p) \
+ ( MPFR_PREC(x) = (p), \
    MPFR_MANT(x) = (xp), \
-   MPFR_SIZE(x) = (s), \
-   MPFR_SET_INVALID_EXP(x))
-/* same when xp is already allocated */
-#define MPFR_INIT1(xp, x, p, s) \
-  (MPFR_PREC(x) = (p), MPFR_MANT(x) = (xp), MPFR_SIZE(x) = (s))
+   MPFR_SET_POS(x), \
+   MPFR_SET_INVALID_EXP(x)) 
+
+#define MPFR_TMP_INIT(xp, x, p, s) \
+  (xp = (mp_ptr) TMP_ALLOC(BYTES_PER_MP_LIMB*(s)), \
+   MPFR_TMP_INIT1(xp, x, p))
 
 #ifndef _PROTO
 #if defined (__STDC__) || defined (__cplusplus)
@@ -287,10 +334,10 @@ extern "C" {
 #endif
 
 extern mpfr_t __mpfr_const_log2;
-extern mp_prec_t __gmpfr_const_log2_prec;
+extern mpfr_prec_t __gmpfr_const_log2_prec;
 
 extern mpfr_t __mpfr_const_pi;
-extern mp_prec_t __gmpfr_const_pi_prec;
+extern mpfr_prec_t __gmpfr_const_pi_prec;
 
 #ifdef HAVE_STRCASECMP
 int strcasecmp _PROTO ((const char *, const char *));
@@ -304,7 +351,7 @@ int strncasecmp _PROTO ((const char *, const char *, size_t));
 int mpfr_strncasecmp _PROTO ((const char *, const char *, size_t));
 #endif
 
-void mpfr_inits2 _PROTO ((mp_prec_t, mpfr_ptr, ...));
+void mpfr_inits2 _PROTO ((mpfr_prec_t, mpfr_ptr, ...));
 void mpfr_inits _PROTO ((mpfr_ptr, ...));
 void mpfr_clears _PROTO ((mpfr_ptr, ...));
 
@@ -316,12 +363,12 @@ int mpfr_add1 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
                        mp_rnd_t, mp_exp_unsigned_t));
 int mpfr_sub1 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr,
                        mp_rnd_t, int));
-int mpfr_round_raw_generic _PROTO ((mp_limb_t *, mp_limb_t *, mp_prec_t, int,
-				    mp_prec_t, mp_rnd_t, int *, int));
+int mpfr_round_raw_generic _PROTO ((mp_limb_t *, mp_limb_t *, mpfr_prec_t, int,
+				    mpfr_prec_t, mp_rnd_t, int *, int));
 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));
+				mp_rnd_t, mp_rnd_t, mpfr_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 *));
+int mpfr_cmp2 _PROTO ((mpfr_srcptr, mpfr_srcptr, mpfr_prec_t *));
 long __gmpfr_ceil_log2 _PROTO ((double));
 long __gmpfr_floor_log2 _PROTO ((double));
 double __gmpfr_ceil_exp2 _PROTO ((double));
diff --git a/mpfr.h b/mpfr.h
index f28838511..e31cf5855 100644
--- a/mpfr.h
+++ b/mpfr.h
@@ -22,75 +22,79 @@ MA 02111-1307, USA. */
 #ifndef __MPFR_H
 #define __MPFR_H
 
-/* check if stdio.h is included */
-#if defined (FILE)                                              \
-  || defined (H_STDIO)                                          \
-  || defined (_H_STDIO)               /* AIX */                 \
-  || defined (_STDIO_H)               /* glibc, Sun, SCO */     \
-  || defined (_STDIO_H_)              /* BSD, OSF */            \
-  || defined (__STDIO_H)              /* Borland */             \
-  || defined (__STDIO_H__)            /* IRIX */                \
-  || defined (_STDIO_INCLUDED)        /* HPUX */                \
-  || defined (__dj_include_stdio_h_)  /* DJGPP */               \
-  || defined (_FILE_DEFINED)          /* Microsoft */           \
-  || defined (__STDIO__)              /* Apple MPW MrC */
+/* Check if GMP is included, and try to include it (Works with local GMP) */
+#ifndef __GMP_H__
+#include <gmp.h>
+#endif
+
+/* Check if stdio.h is included */
+#if defined (EOF)
 #define _MPFR_H_HAVE_FILE 1
 #endif
 
 /* Definition of rounding modes */
-
-#define GMP_RNDN 0
-#define GMP_RNDZ 1
-#define GMP_RNDU 2
-#define GMP_RNDD 3
-
-/* Definition of exponent limits */
-
-#define MPFR_EMAX_DEFAULT ((mp_exp_t) (((unsigned long) 1 << 30) - 1))
-#define MPFR_EMIN_DEFAULT (-(MPFR_EMAX_DEFAULT))
-
-#define MPFR_EMIN_MIN MPFR_EMIN_DEFAULT
-#define MPFR_EMIN_MAX MPFR_EMAX_DEFAULT
-#define MPFR_EMAX_MIN MPFR_EMIN_DEFAULT
-#define MPFR_EMAX_MAX MPFR_EMAX_DEFAULT
-
-/* Flags */
-
+typedef enum {
+  MPFR_RNDN=0,
+  MPFR_RNDZ=1,
+  MPFR_RNDU=2,
+  MPFR_RNDD=3
+} mpfr_rnd_t;
+
+/* Flags of __gmpfr_flags */
 #define MPFR_FLAGS_UNDERFLOW 1
 #define MPFR_FLAGS_OVERFLOW 2
 #define MPFR_FLAGS_NAN 4
 #define MPFR_FLAGS_INEXACT 8
 #define MPFR_FLAGS_ALL 15
 
-/* Definitions of types and their semantics */
+/* Define precision, exponent, sign */
+#if __GMP_MP_SIZE_T_INT == 1
+#define MPFR_EXP_FORMAT_INT
+typedef unsigned int mpfr_prec_t;
+typedef unsigned int mpfr_size_t;
+typedef int          mpfr_exp_t;
+typedef int          mpfr_sign_t;
+#else
+typedef unsigned long mpfr_prec_t;
+typedef unsigned long mpfr_size_t;
+typedef long          mpfr_exp_t;
+typedef int           mpfr_sign_t;
+#endif
 
-typedef unsigned long int mp_prec_t; /* easy to change if necessary */
+/* Definition of precision limits */
 #define MPFR_PREC_MIN 2
-#define MPFR_PREC_MAX (ULONG_MAX >> 1)
-/* Limit mainly due to the multiplication code. */
+#define MPFR_PREC_MAX ((~(mpfr_prec_t)0) >> 1)
 
-typedef int mp_rnd_t;
+/* Definition of the standard exponent limits */
+#define MPFR_EMAX_DEFAULT ((mpfr_exp_t) (((unsigned long) 1 << 30) - 1))
+#define MPFR_EMIN_DEFAULT (-(MPFR_EMAX_DEFAULT))
 
+/* Definition of the intervals of the exponent limits */
+#define MPFR_EMIN_MIN MPFR_EMIN_DEFAULT
+#define MPFR_EMIN_MAX MPFR_EMAX_DEFAULT
+#define MPFR_EMAX_MIN MPFR_EMIN_DEFAULT
+#define MPFR_EMAX_MAX MPFR_EMAX_DEFAULT
+
+/* Definition of the main structure */
 typedef struct {
-  mp_prec_t _mpfr_prec; /* WARNING : for the mpfr type, the precision */
-                              /* should be understood as the number of BITS,*/
-			      /* not the number of mp_limb_t's. This means  */
-			      /* that the corresponding number of allocated
-				 limbs is >= ceil(_mp_prec/BITS_PER_MP_LIMB) */
-  mp_size_t _mpfr_size;         /* MPFR_ABSSIZE(.) is the number of allocated
-				 limbs the field _mp_d points to.
-				 The sign is that of _mpfr_size.
-				 The number 0 is such that _mp_d[k-1]=0
-				 where k = ceil(_mp_prec/BITS_PER_MP_LIMB) */
-  mp_exp_t _mpfr_exp;
-  mp_limb_t *_mpfr_d;
-}
-__mpfr_struct;
+  mpfr_prec_t  _mpfr_prec; 
+  mpfr_sign_t  _mpfr_sign;
+  mpfr_exp_t   _mpfr_exp;
+  mp_limb_t   *_mpfr_d;
+} __mpfr_struct;
+
+/* Compatibility with previous versions of MPFR */
+#define GMP_RNDN MPFR_RNDN
+#define GMP_RNDZ MPFR_RNDZ
+#define GMP_RNDU MPFR_RNDU
+#define GMP_RNDD MPFR_RNDD
+#define mp_rnd_t mpfr_rnd_t
+#define mp_prec_t mpfr_prec_t
 
 /*
-   The number represented is
+   The represented number is
 
-    sign(_mpfr_size)*(_mpfr_d[k-1]/B+_mpfr_d[k-2]/B^2+...+_mpfr_d[0]/B^k)*2^_mpfr_exp
+    _mpfr_sign*(_mpfr_d[k-1]/B+_mpfr_d[k-2]/B^2+...+_mpfr_d[0]/B^k)*2^_mpfr_exp
 
    where k=ceil(_mp_prec/BITS_PER_MP_LIMB) and B=2^BITS_PER_MP_LIMB.
 
@@ -105,10 +109,9 @@ typedef __mpfr_struct mpfr_t[1];
 typedef __mpfr_struct *mpfr_ptr;
 typedef __gmp_const __mpfr_struct *mpfr_srcptr;
 
-#define MPFR_SIGN(x) (((x)->_mpfr_size >> 31) ? -1 : 1)
+#define MPFR_SIGN(x) (((x)->_mpfr_sign))
 
 /* Prototypes */
-
 #ifndef _PROTO
 #if defined (__STDC__) || defined (__cplusplus)
 #define _PROTO(x) x
@@ -138,7 +141,7 @@ void mpfr_clear_underflow _PROTO ((void));
 void mpfr_clear_overflow _PROTO ((void));
 void mpfr_clear_nanflag _PROTO ((void));
 void mpfr_clear_inexflag _PROTO ((void));
-int mpfr_check_range _PROTO ((mpfr_ptr, int, mp_rnd_t));
+int mpfr_check_range _PROTO ((mpfr_ptr, int, mpfr_rnd_t));
 int mpfr_underflow_p _PROTO ((void));
 int mpfr_overflow_p _PROTO ((void));
 int mpfr_nanflag_p _PROTO ((void));
@@ -146,28 +149,28 @@ int mpfr_inexflag_p _PROTO ((void));
 
 void mpfr_init2 _PROTO ((mpfr_ptr, mp_prec_t));
 void mpfr_init _PROTO ((mpfr_ptr));
-int mpfr_prec_round _PROTO ((mpfr_ptr, mp_prec_t, mp_rnd_t));
+int mpfr_prec_round _PROTO ((mpfr_ptr, mp_prec_t, mpfr_rnd_t));
 #define mpfr_round_prec(x,r,p) mpfr_prec_round(x,p,r) /* compatibility 2.0.1 */
-int mpfr_can_round _PROTO ((mpfr_ptr, mp_exp_t, mp_rnd_t, mp_rnd_t,
+int mpfr_can_round _PROTO ((mpfr_ptr, mp_exp_t, mpfr_rnd_t, mpfr_rnd_t,
 			    mp_prec_t));
 mp_exp_t mpfr_get_exp _PROTO ((mpfr_srcptr));
 int mpfr_set_exp _PROTO ((mpfr_ptr, mp_exp_t));
-int mpfr_set_d _PROTO ((mpfr_ptr, double, mp_rnd_t));
-int mpfr_set_ld _PROTO ((mpfr_ptr, long double, mp_rnd_t));
-int mpfr_set_z _PROTO ((mpfr_ptr, mpz_srcptr, mp_rnd_t));
+int mpfr_set_d _PROTO ((mpfr_ptr, double, mpfr_rnd_t));
+int mpfr_set_ld _PROTO ((mpfr_ptr, long double, mpfr_rnd_t));
+int mpfr_set_z _PROTO ((mpfr_ptr, mpz_srcptr, mpfr_rnd_t));
 void mpfr_set_nan _PROTO ((mpfr_ptr));
 void mpfr_set_inf _PROTO ((mpfr_ptr, int));
 mp_exp_t mpfr_get_z_exp _PROTO ((mpz_ptr, mpfr_srcptr));
-int mpfr_set_q _PROTO ((mpfr_ptr, mpq_srcptr, mp_rnd_t));
-double mpfr_get_d _PROTO ((mpfr_srcptr, mp_rnd_t));
-long double mpfr_get_ld _PROTO ((mpfr_srcptr, mp_rnd_t));
+int mpfr_set_q _PROTO ((mpfr_ptr, mpq_srcptr, mpfr_rnd_t));
+double mpfr_get_d _PROTO ((mpfr_srcptr, mpfr_rnd_t));
+long double mpfr_get_ld _PROTO ((mpfr_srcptr, mpfr_rnd_t));
 double mpfr_get_d1 _PROTO ((mpfr_srcptr));
-double mpfr_get_d_2exp _PROTO ((long *, mpfr_srcptr, mp_rnd_t));
-long mpfr_get_si _PROTO ((mpfr_srcptr, mp_rnd_t));
-unsigned long mpfr_get_ui _PROTO ((mpfr_srcptr, mp_rnd_t));
-int mpfr_set_f _PROTO ((mpfr_ptr, mpf_srcptr, mp_rnd_t));
-int mpfr_set_si _PROTO ((mpfr_ptr, long, mp_rnd_t));
-int mpfr_set_ui _PROTO ((mpfr_ptr, unsigned long, mp_rnd_t));
+double mpfr_get_d_2exp _PROTO ((long *, mpfr_srcptr, mpfr_rnd_t));
+long mpfr_get_si _PROTO ((mpfr_srcptr, mpfr_rnd_t));
+unsigned long mpfr_get_ui _PROTO ((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_set_f _PROTO ((mpfr_ptr, mpf_srcptr, mpfr_rnd_t));
+int mpfr_set_si _PROTO ((mpfr_ptr, long, mpfr_rnd_t));
+int mpfr_set_ui _PROTO ((mpfr_ptr, unsigned long, mpfr_rnd_t));
 void mpfr_random _PROTO ((mpfr_ptr));
 void mpfr_random2 _PROTO ((mpfr_ptr, mp_size_t, mp_exp_t));
 int mpfr_urandomb _PROTO ((mpfr_ptr, gmp_randstate_t));
@@ -175,77 +178,80 @@ void mpfr_clear _PROTO ((mpfr_ptr));
 void mpfr_nextabove _PROTO ((mpfr_ptr));
 void mpfr_nextbelow _PROTO ((mpfr_ptr));
 void mpfr_nexttoward _PROTO ((mpfr_ptr, mpfr_srcptr));
-int mpfr_set_str _PROTO ((mpfr_ptr, __gmp_const char *, int, mp_rnd_t));
-int mpfr_init_set_str _PROTO ((mpfr_ptr, __gmp_const char *, int, mp_rnd_t));
-char* mpfr_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpfr_srcptr, mp_rnd_t));
+int mpfr_set_str _PROTO ((mpfr_ptr, __gmp_const char *, int, mpfr_rnd_t));
+int mpfr_init_set_str _PROTO ((mpfr_ptr, __gmp_const char *, int, mpfr_rnd_t));
+char* mpfr_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpfr_srcptr, mpfr_rnd_t));
 #ifdef _MPFR_H_HAVE_FILE
-size_t mpfr_inp_str _PROTO ((mpfr_ptr, FILE *, int, mp_rnd_t));
-size_t mpfr_out_str _PROTO ((FILE *, int, size_t, mpfr_srcptr, mp_rnd_t));
+  /* They are only accessible if you include stdio.h first */ 
+#define mpfr_inp_str mpfr_inp_str_internal
+#define mpfr_out_str mpfr_out_str_internal
+size_t mpfr_inp_str _PROTO ((mpfr_ptr, FILE *, int, mpfr_rnd_t));
+size_t mpfr_out_str _PROTO ((FILE *, int, size_t, mpfr_srcptr, mpfr_rnd_t));
 #endif
-int mpfr_mul _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_pow_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
+int mpfr_mul _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_pow_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
 int mpfr_ui_pow_ui _PROTO ((mpfr_ptr, unsigned long int, unsigned long int,
-			     mp_rnd_t));
-int mpfr_div _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_agm _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_sqrt _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_sqrt_ui _PROTO ((mpfr_ptr, unsigned long, mp_rnd_t));
-int mpfr_add _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_add_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long, mp_rnd_t));
-int mpfr_sub_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long, mp_rnd_t));
-int mpfr_add_one_ulp _PROTO ((mpfr_ptr, mp_rnd_t));
-int mpfr_sub _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_ui_sub _PROTO ((mpfr_ptr, unsigned long, mpfr_srcptr, mp_rnd_t));
-void mpfr_reldiff _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_const_pi _PROTO ((mpfr_ptr, mp_rnd_t));
-int mpfr_const_log2 _PROTO ((mpfr_ptr, mp_rnd_t));
-int mpfr_const_euler _PROTO ((mpfr_ptr, mp_rnd_t));
-int mpfr_log _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_exp _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_exp2 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_sin _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_sin_cos _PROTO ((mpfr_ptr, mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_cos _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_tan _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_mul_ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
+			     mpfr_rnd_t));
+int mpfr_div _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_agm _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sqrt _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sqrt_ui _PROTO ((mpfr_ptr, unsigned long, mpfr_rnd_t));
+int mpfr_add _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_add_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t));
+int mpfr_sub_ui _PROTO ((mpfr_ptr, mpfr_srcptr, unsigned long, mpfr_rnd_t));
+int mpfr_add_one_ulp _PROTO ((mpfr_ptr, mpfr_rnd_t));
+int mpfr_sub _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_ui_sub _PROTO ((mpfr_ptr, unsigned long, mpfr_srcptr, mpfr_rnd_t));
+void mpfr_reldiff _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_const_pi _PROTO ((mpfr_ptr, mpfr_rnd_t));
+int mpfr_const_log2 _PROTO ((mpfr_ptr, mpfr_rnd_t));
+int mpfr_const_euler _PROTO ((mpfr_ptr, mpfr_rnd_t));
+int mpfr_log _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_exp _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_exp2 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sin _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sin_cos _PROTO ((mpfr_ptr, mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_cos _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_tan _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_mul_ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
 int mpfr_cmp_ui_2exp _PROTO ((mpfr_srcptr, unsigned long int, mp_exp_t));
 int mpfr_cmp_si_2exp _PROTO ((mpfr_srcptr, long int, mp_exp_t));
-int mpfr_mul_2exp _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
-int mpfr_div_2exp _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
-int mpfr_mul_2ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
-int mpfr_div_2ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
-int mpfr_mul_2si _PROTO((mpfr_ptr, mpfr_srcptr, long int, mp_rnd_t));
-int mpfr_div_2si _PROTO((mpfr_ptr, mpfr_srcptr, long int, mp_rnd_t));
+int mpfr_mul_2exp _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
+int mpfr_div_2exp _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
+int mpfr_mul_2ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
+int mpfr_div_2ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
+int mpfr_mul_2si _PROTO((mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t));
+int mpfr_div_2si _PROTO((mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t));
 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));
 extern mp_prec_t __gmpfr_default_fp_bit_precision;
-extern mp_rnd_t __gmpfr_default_rounding_mode;
-__gmp_const 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));
-int mpfr_div_ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t));
-int mpfr_ui_div _PROTO((mpfr_ptr, unsigned long int, mpfr_srcptr, mp_rnd_t));
+extern mpfr_rnd_t __gmpfr_default_rounding_mode;
+__gmp_const char * mpfr_print_rnd_mode _PROTO((mpfr_rnd_t));
+int mpfr_neg _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sub_one_ulp _PROTO((mpfr_ptr, mpfr_rnd_t));
+int mpfr_div_ui _PROTO((mpfr_ptr, mpfr_srcptr, unsigned long int, mpfr_rnd_t));
+int mpfr_ui_div _PROTO((mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t));
 mp_prec_t mpfr_get_prec _PROTO((mpfr_srcptr));
-void mpfr_set_default_rounding_mode _PROTO((mp_rnd_t));
+void mpfr_set_default_rounding_mode _PROTO((mpfr_rnd_t));
 int mpfr_eq _PROTO((mpfr_srcptr, mpfr_srcptr, unsigned long));
-int mpfr_rint _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
+int mpfr_rint _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
 int mpfr_round _PROTO((mpfr_ptr, mpfr_srcptr));
 int mpfr_trunc _PROTO((mpfr_ptr, mpfr_srcptr));
 int mpfr_ceil _PROTO((mpfr_ptr, mpfr_srcptr));
 int mpfr_floor _PROTO((mpfr_ptr, mpfr_srcptr));
-int mpfr_frac _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_ulong_p _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_slong_p _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_uint_p _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_sint_p _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_ushort_p _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_fits_sshort_p _PROTO((mpfr_srcptr, mp_rnd_t));
+int mpfr_frac _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_ulong_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_slong_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_uint_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_sint_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_ushort_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fits_sshort_p _PROTO((mpfr_srcptr, mpfr_rnd_t));
 void mpfr_extract _PROTO((mpz_ptr, mpfr_srcptr, unsigned int));
 void mpfr_swap _PROTO((mpfr_ptr, mpfr_ptr));
-void mpfr_dump _PROTO((mpfr_srcptr, mp_rnd_t));
-int mpfr_set4 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t, int));
+void mpfr_dump _PROTO((mpfr_srcptr, mpfr_rnd_t));
+int mpfr_set4 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t, int));
 int mpfr_cmp3 _PROTO ((mpfr_srcptr, mpfr_srcptr, int));
 int mpfr_cmp_d _PROTO ((mpfr_srcptr, double));
 int mpfr_cmpabs _PROTO ((mpfr_srcptr, mpfr_srcptr));
@@ -253,53 +259,53 @@ int mpfr_cmpabs _PROTO ((mpfr_srcptr, mpfr_srcptr));
 int mpfr_nan_p _PROTO((mpfr_srcptr));
 int mpfr_inf_p _PROTO((mpfr_srcptr));
 int mpfr_number_p _PROTO((mpfr_srcptr));
-int mpfr_acos _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_asin _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_atan _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_erf _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-
-int mpfr_sinh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_tanh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_factorial _PROTO ((mpfr_ptr, unsigned long int, mp_rnd_t));
-int mpfr_ui_pow _PROTO ((mpfr_ptr, unsigned long int, mpfr_srcptr, mp_rnd_t));
-
-int mpfr_atanh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_acosh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_asinh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-
-int mpfr_cosh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_sinh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_tanh _PROTO((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_asin _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_atan _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_fac_ui _PROTO ((mpfr_ptr, unsigned long int, mp_rnd_t));
-int mpfr_fma _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_hypot _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_pow _PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_srcptr, mp_rnd_t));
-int mpfr_pow_si _PROTO ((mpfr_ptr, mpfr_srcptr, long int, mp_rnd_t));
+int mpfr_acos _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_asin _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_atan _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_erf _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+
+int mpfr_sinh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_tanh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_factorial _PROTO ((mpfr_ptr, unsigned long int, mpfr_rnd_t));
+int mpfr_ui_pow _PROTO ((mpfr_ptr, unsigned long int, mpfr_srcptr, mpfr_rnd_t));
+
+int mpfr_atanh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_acosh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_asinh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+
+int mpfr_cosh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_sinh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_tanh _PROTO((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_asin _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_atan _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_fac_ui _PROTO ((mpfr_ptr, unsigned long int, mpfr_rnd_t));
+int mpfr_fma _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_hypot _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_pow _PROTO ((mpfr_ptr, mpfr_srcptr,mpfr_srcptr, mpfr_rnd_t));
+int mpfr_pow_si _PROTO ((mpfr_ptr, mpfr_srcptr, long int, mpfr_rnd_t));
 int mpfr_integer_p _PROTO ((mpfr_srcptr));
-int mpfr_log2 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_log10 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_log1p _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_expm1 _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_cbrt _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_gamma _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_zeta _PROTO ((mpfr_ptr, mpfr_srcptr, mp_rnd_t));
-
-int mpfr_min _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_max _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_dim _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-int mpfr_copysign _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
-
-int mpfr_mul_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mp_rnd_t));
-int mpfr_div_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mp_rnd_t));
-int mpfr_add_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mp_rnd_t));
-int mpfr_sub_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mp_rnd_t));
-
-int mpfr_mul_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mp_rnd_t));
-int mpfr_div_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mp_rnd_t));
-int mpfr_add_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mp_rnd_t));
-int mpfr_sub_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mp_rnd_t));
+int mpfr_log2 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_log10 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_log1p _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_expm1 _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_cbrt _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_gamma _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_zeta _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_rnd_t));
+
+int mpfr_min _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_max _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_dim _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+int mpfr_copysign _PROTO ((mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_rnd_t));
+
+int mpfr_mul_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t));
+int mpfr_div_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t));
+int mpfr_add_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t));
+int mpfr_sub_z _PROTO ((mpfr_ptr, mpfr_srcptr, mpz_srcptr, mpfr_rnd_t));
+
+int mpfr_mul_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t));
+int mpfr_div_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t));
+int mpfr_add_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t));
+int mpfr_sub_q _PROTO ((mpfr_ptr, mpfr_srcptr, mpq_srcptr, mpfr_rnd_t));
 
 int mpfr_greater_p _PROTO ((mpfr_srcptr, mpfr_srcptr));
 int mpfr_greaterequal_p _PROTO ((mpfr_srcptr, mpfr_srcptr));
diff --git a/rint.c b/rint.c
index 2c2fa461f..d08007aad 100644
--- a/rint.c
+++ b/rint.c
@@ -114,8 +114,8 @@ mpfr_rint (mpfr_ptr r, mpfr_srcptr u, mp_rnd_t rnd_mode)
       up = MPFR_MANT(u);
       rp = MPFR_MANT(r);
 
-      un = MPFR_ESIZE(u);
-      rn = MPFR_ESIZE(r);
+      un = MPFR_LIMB_SIZE(u);
+      rn = MPFR_LIMB_SIZE(r);
       sh = (mp_prec_t) rn * BITS_PER_MP_LIMB - MPFR_PREC(r);
 
       MPFR_SET_EXP (r, exp);
diff --git a/round_prec.c b/round_prec.c
index 6440d53fd..c86733123 100644
--- a/round_prec.c
+++ b/round_prec.c
@@ -158,7 +158,7 @@ mpfr_prec_round (mpfr_ptr x, mp_prec_t prec, mp_rnd_t rnd_mode)
 {
   mp_limb_t *tmp, *xp;
   int carry, inexact;
-  mp_prec_t nw;
+  mp_prec_t nw, ow;
   TMP_DECL(marker);
 
   MPFR_ASSERTN(prec >= MPFR_PREC_MIN && prec <= MPFR_PREC_MAX);
@@ -166,12 +166,13 @@ mpfr_prec_round (mpfr_ptr x, mp_prec_t prec, mp_rnd_t rnd_mode)
   nw = 1 + (prec - 1) / BITS_PER_MP_LIMB; /* needed allocated limbs */
 
   /* check if x has enough allocated space for the mantissa */
-  if (nw > MPFR_ABSSIZE(x))
+  ow = MPFR_GET_ALLOC_SIZE(x);
+  if (nw > ow)
     {
-      MPFR_MANT(x) = (mp_ptr) (*__gmp_reallocate_func)
-        (MPFR_MANT(x), (size_t) MPFR_ABSSIZE(x) * BYTES_PER_MP_LIMB,
-         (size_t) nw * BYTES_PER_MP_LIMB);
-      MPFR_SET_ABSSIZE(x, nw); /* new number of allocated limbs */
+      mp_ptr tmp = (mp_ptr) (*__gmp_reallocate_func)
+        (MPFR_GET_REAL_PTR(x),  MPFR_ALLOC_SIZE(ow), MPFR_ALLOC_SIZE(nw));
+      MPFR_SET_MANT_PTR(x, tmp);
+      MPFR_SET_ALLOC_SIZE(x, nw); /* new number of allocated limbs */
     }
 
   if (MPFR_IS_NAN(x))
diff --git a/set.c b/set.c
index cbd56b1ce..16f43b36c 100644
--- a/set.c
+++ b/set.c
@@ -78,7 +78,6 @@ mpfr_set4 (mpfr_ptr a, mpfr_srcptr b, mp_rnd_t rnd_mode, int signb)
         }
     }
 
-  if (MPFR_SIGN(a) * signb < 0)
-    MPFR_CHANGE_SIGN(a);
+  MPFR_SET_SIGN(a, signb);
   MPFR_RET(inex);
 }
diff --git a/set_d.c b/set_d.c
index a6fa6bf42..7e5672b14 100644
--- a/set_d.c
+++ b/set_d.c
@@ -188,8 +188,10 @@ mpfr_set_d (mpfr_ptr r, double d, mp_rnd_t rnd_mode)
   else if (DOUBLE_ISINF(d))
     {
       MPFR_SET_INF(r);
-      if ((d > 0 && (MPFR_SIGN(r) == -1)) || (d < 0 && (MPFR_SIGN(r) == 1)))
-	MPFR_CHANGE_SIGN(r);
+      if (d > 0)
+	MPFR_SET_POS(r);
+      else
+	MPFR_SET_NEG(r);
       return 0; /* infinity is exact */
     }
 
@@ -198,9 +200,9 @@ mpfr_set_d (mpfr_ptr r, double d, mp_rnd_t rnd_mode)
      would have same precision in the mpfr_set4 call below. */
   MPFR_MANT(tmp) = tmpmant;
   MPFR_PREC(tmp) = IEEE_DBL_MANT_DIG;
-  MPFR_SIZE(tmp) = MPFR_LIMBS_PER_DOUBLE;
+  /*MPFR_SIZE(tmp) = MPFR_LIMBS_PER_DOUBLE;*/
 
-  signd = (d < 0) ? -1 : 1;
+  signd = (d < 0) ? MPFR_SIGN_NEG : MPFR_SIGN_POS;
   d = ABS (d);
 
   MPFR_SET_EXP(tmp, __mpfr_extract_double (tmpmant, d));
diff --git a/set_prc_raw.c b/set_prc_raw.c
index feb4b4e58..2bc8e1d45 100644
--- a/set_prc_raw.c
+++ b/set_prc_raw.c
@@ -27,11 +27,11 @@ MA 02111-1307, USA. */
 #include "mpfr-impl.h"
 
 void
-mpfr_set_prec_raw (mpfr_ptr x, mp_prec_t p)
+mpfr_set_prec_raw (mpfr_ptr x, mpfr_prec_t p)
 {
   MPFR_ASSERTN(p >= MPFR_PREC_MIN && p <= MPFR_PREC_MAX);
 
-  if (p > (mp_prec_t) MPFR_ABSSIZE(x) * BITS_PER_MP_LIMB)
+  if (p > (mpfr_prec_t) MPFR_GET_ALLOC_SIZE(x) * BITS_PER_MP_LIMB)
     {
       fprintf (stderr, "*** precision too large for allocated space\n");
       exit (1);
diff --git a/set_prec.c b/set_prec.c
index 10e909e69..eac0191b7 100644
--- a/set_prec.c
+++ b/set_prec.c
@@ -26,22 +26,26 @@ MA 02111-1307, USA. */
 #include "mpfr-impl.h"
 
 void
-mpfr_set_prec (mpfr_ptr x, mp_prec_t p)
+mpfr_set_prec (mpfr_ptr x, mpfr_prec_t p)
 {
-  mp_size_t xsize;
+  mpfr_size_t xsize, xoldsize;
+  mp_ptr tmp;
 
+  /* first, check if p is correct */
   MPFR_ASSERTN(p >= MPFR_PREC_MIN && p <= MPFR_PREC_MAX);
 
-  xsize = (p - 1) / BITS_PER_MP_LIMB + 1; /* new limb size */
+  /* Calculate the new number of limbs */ 
+  xsize = (p - 1) / BITS_PER_MP_LIMB + 1;
 
-  if (xsize > MPFR_ABSSIZE(x))
+  /* Realloc only if the new size is greater than the old */
+  xoldsize = MPFR_GET_ALLOC_SIZE(x);
+  if (xsize > xoldsize)
     {
-      MPFR_MANT(x) = (mp_ptr) (*__gmp_reallocate_func)
-        (MPFR_MANT(x), (size_t) MPFR_ABSSIZE(x) * BYTES_PER_MP_LIMB,
-         (size_t) xsize * BYTES_PER_MP_LIMB);
-      MPFR_SIZE(x) = xsize; /* new number of allocated limbs */
+      tmp = (mp_ptr) (*__gmp_reallocate_func)
+        (MPFR_GET_REAL_PTR(x), MPFR_ALLOC_SIZE(xoldsize), MPFR_ALLOC_SIZE(xsize));
+      MPFR_SET_MANT_PTR(x, tmp);
+      MPFR_SET_ALLOC_SIZE(x, xsize);
     }
-
   MPFR_PREC(x) = p;
   MPFR_SET_NAN(x); /* initializes to NaN */
 }
diff --git a/set_str.c b/set_str.c
index ca02a7ae6..537988a42 100644
--- a/set_str.c
+++ b/set_str.c
@@ -356,7 +356,7 @@ mpfr_set_str (mpfr_t x, const char *str, int base, mp_rnd_t rnd)
 			      negative, MPFR_PREC(x), rnd, NULL, (int) 0))
     {
       /* overflaw when rounding y */
-      MPFR_MANT(x)[MPFR_ESIZE(x) - 1] 
+      MPFR_MANT(x)[MPFR_LIMB_SIZE(x) - 1] 
 	= MPFR_LIMB_HIGHBIT;
       exp_y ++;
     }
diff --git a/set_str_raw.c b/set_str_raw.c
index ecb724660..f367de663 100644
--- a/set_str_raw.c
+++ b/set_str_raw.c
@@ -42,7 +42,7 @@ mpfr_set_str_binary (mpfr_ptr x, const char *str)
   char *endstr2;
 
   xp = MPFR_MANT(x);
-  xsize = 1 + (MPFR_PREC(x) - 1) / BITS_PER_MP_LIMB;
+  xsize = MPFR_LIMB_SIZE(x);
   alloc = strlen(str) + 1;
 
   if (*str == '-')
@@ -145,8 +145,10 @@ mpfr_set_str_binary (mpfr_ptr x, const char *str)
         mpn_lshift(xp, xp, xsize, cnt);
 
       MPFR_SET_EXP (x, expn - cnt);
-      if (MPFR_ISNEG(x) != negative)
-        MPFR_CHANGE_SIGN(x);
+      if (negative)
+	MPFR_SET_NEG(x);
+      else
+	MPFR_SET_POS(x);
     }
 
   (*__gmp_free_func) (str0, alloc);
diff --git a/sqrt_ui.c b/sqrt_ui.c
index 0a0feb15a..4b59e086d 100644
--- a/sqrt_ui.c
+++ b/sqrt_ui.c
@@ -35,7 +35,7 @@ mpfr_sqrt_ui (mpfr_ptr r, unsigned long u, mp_rnd_t rnd_mode)
       unsigned long cnt;
       int inex;
 
-      MPFR_INIT1(up, uu, BITS_PER_MP_LIMB, 1);
+      MPFR_TMP_INIT1(up, uu, BITS_PER_MP_LIMB);
       MPFR_ASSERTN(u == (mp_limb_t) u);
       count_leading_zeros (cnt, (mp_limb_t) u);
       *up = (mp_limb_t) u << cnt;
diff --git a/sub_ui.c b/sub_ui.c
index 6c6059f77..1a9a82c5e 100644
--- a/sub_ui.c
+++ b/sub_ui.c
@@ -35,7 +35,7 @@ mpfr_sub_ui (mpfr_ptr y, mpfr_srcptr x, unsigned long int u, mp_rnd_t rnd_mode)
     unsigned long cnt;
     int inex;
 
-    MPFR_INIT1(up, uu, BITS_PER_MP_LIMB, 1);
+    MPFR_TMP_INIT1(up, uu, BITS_PER_MP_LIMB);
     MPFR_ASSERTN(u == (mp_limb_t) u);
     count_leading_zeros(cnt, (mp_limb_t) u);
     *up = (mp_limb_t) u << cnt;
diff --git a/ui_div.c b/ui_div.c
index 6fff18546..f99372597 100644
--- a/ui_div.c
+++ b/ui_div.c
@@ -45,8 +45,7 @@ mpfr_ui_div (mpfr_ptr y, unsigned long int u, mpfr_srcptr x, mp_rnd_t rnd_mode)
     {
       MPFR_CLEAR_INF(y);
       MPFR_SET_ZERO(y);
-      if (MPFR_SIGN(x) != MPFR_SIGN(y))
-	MPFR_CHANGE_SIGN(y);
+      MPFR_SET_SAME_SIGN(y,x);
       MPFR_RET(0);
     }
 
@@ -54,7 +53,7 @@ mpfr_ui_div (mpfr_ptr y, unsigned long int u, mpfr_srcptr x, mp_rnd_t rnd_mode)
 
   if (u)
     {
-      MPFR_INIT1(up, uu, BITS_PER_MP_LIMB, 1);
+      MPFR_TMP_INIT1(up, uu, BITS_PER_MP_LIMB);
       MPFR_ASSERTN(u == (mp_limb_t) u);
       count_leading_zeros(cnt, (mp_limb_t) u);
       *up = (mp_limb_t) u << cnt;
diff --git a/ui_sub.c b/ui_sub.c
index 5942c2d28..b42cdea3c 100644
--- a/ui_sub.c
+++ b/ui_sub.c
@@ -50,7 +50,7 @@ mpfr_ui_sub (mpfr_ptr y, unsigned long int u, mpfr_srcptr x, mp_rnd_t rnd_mode)
 
   if (u)
     {
-      MPFR_INIT1 (up, uu, BITS_PER_MP_LIMB, 1);
+      MPFR_TMP_INIT1 (up, uu, BITS_PER_MP_LIMB);
       MPFR_ASSERTN(u == (mp_limb_t) u);
       count_leading_zeros (cnt, (mp_limb_t) u);
       *up = (mp_limb_t) u << cnt;
diff --git a/urandomb.c b/urandomb.c
index 2ac85ec01..55b1a06ca 100644
--- a/urandomb.c
+++ b/urandomb.c
@@ -42,7 +42,8 @@ mpfr_urandomb (mpfr_ptr rop, gmp_randstate_t rstate)
 
   rp = MPFR_MANT(rop);
   nbits = MPFR_PREC(rop);
-  nlimbs = (nbits + BITS_PER_MP_LIMB - 1) / BITS_PER_MP_LIMB;
+  nlimbs = MPFR_LIMB_SIZE(rop);
+  /*(nbits + BITS_PER_MP_LIMB - 1) / BITS_PER_MP_LIMB;*/
 
   _gmp_rand (rp, rstate, nlimbs * BITS_PER_MP_LIMB);
 
@@ -74,6 +75,8 @@ mpfr_urandomb (mpfr_ptr rop, gmp_randstate_t rstate)
       if (k)
         MPN_ZERO (rp, k);
     }
+  else
+    MPFR_SET_ZERO(rop);
 
   MPFR_SET_POS (rop);
   return 0;