Thu Oct 17 01:13:29 PDT 2013

2 files changed, 788 insertions, 7 deletions

diff --git a/core/mpfr/PKGBUILD b/core/mpfr/PKGBUILD
index d47204c74..92977d037 100644
--- a/core/mpfr/PKGBUILD
+++ b/core/mpfr/PKGBUILD
@@ -1,12 +1,12 @@
-# $Id: PKGBUILD 180068 2013-03-15 22:55:34Z allan $
+# $Id: PKGBUILD 196659 2013-10-16 04:16:15Z allan $
 # Maintainer: Allan McRae <allan@archlinux.org>
 # Contributor: damir <damir@archlinux.org>
 
 pkgname=mpfr
 _pkgver=3.1.2
-#_patchlevel=p1
-#pkgver=${_pkgver}.${_patchlevel}
-pkgver=${_pkgver}
+_patchlevel=p3
+pkgver=${_pkgver}.${_patchlevel}
+#pkgver=${_pkgver}
 pkgrel=1
 pkgdesc="Multiple-precision floating-point library"
 arch=('i686' 'x86_64')
@@ -15,13 +15,15 @@ license=('LGPL')
 depends=('gmp>=5.0')
 options=('!libtool')
 install=mpfr.install
-source=(http://www.mpfr.org/mpfr-current/mpfr-${_pkgver}.tar.xz{,.asc})
+source=(http://www.mpfr.org/mpfr-current/mpfr-${_pkgver}.tar.xz{,.asc}
+        mpfr-${_pkgver}-${_patchlevel}.patch)
 md5sums=('e3d203d188b8fe60bb6578dd3152e05c'
-         '63d1a00bedd4fed3717115297f70d029')
+         'SKIP'
+         'd22c975afc8599b06dd0d6c1128ac078')
 
 build() {
   cd "${srcdir}/${pkgname}-${_pkgver}"
-  #patch -p1 -i $srcdir/mpfr-${_pkgver}-${_patchlevel}.patch
+  patch -p1 -i $srcdir/mpfr-${_pkgver}-${_patchlevel}.patch
   ./configure --prefix=/usr --enable-thread-safe --enable-shared
   make
 }
diff --git a/core/mpfr/mpfr-3.1.2-p3.patch b/core/mpfr/mpfr-3.1.2-p3.patch
new file mode 100644
index 000000000..0339944b6
--- /dev/null
+++ b/core/mpfr/mpfr-3.1.2-p3.patch
@@ -0,0 +1,779 @@
+diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
+--- mpfr-3.1.2-a/PATCHES	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/PATCHES	2013-09-26 10:52:52.000000000 +0000
+@@ -0,0 +1 @@
++exp_2
+diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
+--- mpfr-3.1.2-a/VERSION	2013-03-13 15:37:28.000000000 +0000
++++ mpfr-3.1.2-b/VERSION	2013-09-26 10:52:52.000000000 +0000
+@@ -1 +1 @@
+-3.1.2
++3.1.2-p1
+diff -Naurd mpfr-3.1.2-a/src/exp_2.c mpfr-3.1.2-b/src/exp_2.c
+--- mpfr-3.1.2-a/src/exp_2.c	2013-03-13 15:37:28.000000000 +0000
++++ mpfr-3.1.2-b/src/exp_2.c	2013-09-26 10:52:52.000000000 +0000
+@@ -204,7 +204,7 @@
+           for (k = 0; k < K; k++)
+             {
+               mpz_mul (ss, ss, ss);
+-              exps <<= 1;
++              exps *= 2;
+               exps += mpz_normalize (ss, ss, q);
+             }
+           mpfr_set_z (s, ss, MPFR_RNDN);
+diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
+--- mpfr-3.1.2-a/src/mpfr.h	2013-03-13 15:37:37.000000000 +0000
++++ mpfr-3.1.2-b/src/mpfr.h	2013-09-26 10:52:52.000000000 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 3
+ #define MPFR_VERSION_MINOR 1
+ #define MPFR_VERSION_PATCHLEVEL 2
+-#define MPFR_VERSION_STRING "3.1.2"
++#define MPFR_VERSION_STRING "3.1.2-p1"
+ 
+ /* Macros dealing with MPFR VERSION */
+ #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
+diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
+--- mpfr-3.1.2-a/src/version.c	2013-03-13 15:37:34.000000000 +0000
++++ mpfr-3.1.2-b/src/version.c	2013-09-26 10:52:52.000000000 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+-  return "3.1.2";
++  return "3.1.2-p1";
+ }
+diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
+--- mpfr-3.1.2-a/PATCHES	2013-09-26 10:56:55.000000000 +0000
++++ mpfr-3.1.2-b/PATCHES	2013-09-26 10:56:55.000000000 +0000
+@@ -0,0 +1 @@
++fits-smallneg
+diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
+--- mpfr-3.1.2-a/VERSION	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/VERSION	2013-09-26 10:56:55.000000000 +0000
+@@ -1 +1 @@
+-3.1.2-p1
++3.1.2-p2
+diff -Naurd mpfr-3.1.2-a/src/fits_u.h mpfr-3.1.2-b/src/fits_u.h
+--- mpfr-3.1.2-a/src/fits_u.h	2013-03-13 15:37:35.000000000 +0000
++++ mpfr-3.1.2-b/src/fits_u.h	2013-09-26 10:56:55.000000000 +0000
+@@ -32,17 +32,20 @@
+   int res;
+ 
+   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
+-    /* Zero always fit */
+-    return MPFR_IS_ZERO (f) ? 1 : 0;
+-  else if (MPFR_IS_NEG (f))
+-    /* Negative numbers don't fit */
+-    return 0;
+-  /* now it fits if
+-     (a) f <= MAXIMUM
+-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
++    return MPFR_IS_ZERO (f) ? 1 : 0;  /* Zero always fits */
+ 
+   e = MPFR_GET_EXP (f);
+ 
++  if (MPFR_IS_NEG (f))
++    return e >= 1 ? 0  /* f <= -1 does not fit */
++      : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1)  /* directed mode */
++      : e < 0 ? 1  /* f > -1/2 fits in MPFR_RNDN */
++      : mpfr_powerof2_raw(f);  /* -1/2 fits, -1 < f < -1/2 don't */
++
++  /* Now it fits if
++     (a) f <= MAXIMUM
++     (b) round(f, prec(slong), rnd) <= MAXIMUM */
++
+   /* first compute prec(MAXIMUM); fits in an int */
+   for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++);
+ 
+diff -Naurd mpfr-3.1.2-a/src/fits_uintmax.c mpfr-3.1.2-b/src/fits_uintmax.c
+--- mpfr-3.1.2-a/src/fits_uintmax.c	2013-03-13 15:37:33.000000000 +0000
++++ mpfr-3.1.2-b/src/fits_uintmax.c	2013-09-26 10:56:55.000000000 +0000
+@@ -27,51 +27,19 @@
+ #include "mpfr-intmax.h"
+ #include "mpfr-impl.h"
+ 
+-#ifdef _MPFR_H_HAVE_INTMAX_T
+-
+-/* We can't use fits_u.h <= mpfr_cmp_ui */
+-int
+-mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd)
+-{
+-  mpfr_exp_t e;
+-  int prec;
+-  uintmax_t s;
+-  mpfr_t x;
+-  int res;
+-
+-  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
+-    /* Zero always fit */
+-    return MPFR_IS_ZERO (f) ? 1 : 0;
+-  else if (MPFR_IS_NEG (f))
+-    /* Negative numbers don't fit */
+-    return 0;
+-  /* now it fits if
+-     (a) f <= MAXIMUM
+-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
+-
+-  e = MPFR_GET_EXP (f);
+-
+-  /* first compute prec(MAXIMUM); fits in an int */
+-  for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++);
+-
+-  /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */
+-
+-  /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */
+-  if (e <= prec - 1)
+-    return 1;
++/* Note: though mpfr-impl.h is included in fits_u.h, we also include it
++   above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not
++   defined; this is necessary to avoid an empty translation unit, which
++   is forbidden by ISO C. Without this, a failing test can be reproduced
++   by creating an invalid stdint.h somewhere in the default include path
++   and by compiling MPFR with "gcc -ansi -pedantic-errors". */
+ 
+-  /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */
+-  if (e >= prec + 1)
+-    return 0;
++#ifdef _MPFR_H_HAVE_INTMAX_T
+ 
+-  MPFR_ASSERTD (e == prec);
++#define FUNCTION   mpfr_fits_uintmax_p
++#define MAXIMUM    MPFR_UINTMAX_MAX
++#define TYPE       uintmax_t
+ 
+-  /* hard case: first round to prec bits, then check */
+-  mpfr_init2 (x, prec);
+-  mpfr_set (x, f, rnd);
+-  res = MPFR_GET_EXP (x) == e;
+-  mpfr_clear (x);
+-  return res;
+-}
++#include "fits_u.h"
+ 
+ #endif
+diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
+--- mpfr-3.1.2-a/src/mpfr.h	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/src/mpfr.h	2013-09-26 10:56:55.000000000 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 3
+ #define MPFR_VERSION_MINOR 1
+ #define MPFR_VERSION_PATCHLEVEL 2
+-#define MPFR_VERSION_STRING "3.1.2-p1"
++#define MPFR_VERSION_STRING "3.1.2-p2"
+ 
+ /* Macros dealing with MPFR VERSION */
+ #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
+diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
+--- mpfr-3.1.2-a/src/version.c	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/src/version.c	2013-09-26 10:56:55.000000000 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+-  return "3.1.2-p1";
++  return "3.1.2-p2";
+ }
+diff -Naurd mpfr-3.1.2-a/tests/tfits.c mpfr-3.1.2-b/tests/tfits.c
+--- mpfr-3.1.2-a/tests/tfits.c	2013-03-13 15:37:45.000000000 +0000
++++ mpfr-3.1.2-b/tests/tfits.c	2013-09-26 10:56:55.000000000 +0000
+@@ -33,155 +33,176 @@
+ #include "mpfr-intmax.h"
+ #include "mpfr-test.h"
+ 
+-#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); }
+-#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); }
++#define ERROR1(N)                                               \
++  do                                                            \
++    {                                                           \
++      printf("Error %d for rnd = %s and x = ", N,               \
++             mpfr_print_rnd_mode ((mpfr_rnd_t) r));             \
++      mpfr_dump(x);                                             \
++      exit(1);                                                  \
++    }                                                           \
++  while (0)
+ 
+ static void check_intmax (void);
+ 
+ int
+ main (void)
+ {
+-  mpfr_t x;
++  mpfr_t x, y;
++  int i, r;
+ 
+   tests_start_mpfr ();
+ 
+   mpfr_init2 (x, 256);
++  mpfr_init2 (y, 8);
+ 
+-  /* Check NAN */
+-  mpfr_set_nan (x);
+-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR1;
++  RND_LOOP (r)
++    {
+ 
+-  /* Check INF */
+-  mpfr_set_inf (x, 1);
+-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check NAN */
++      mpfr_set_nan (x);
++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (1);
++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (2);
++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (3);
++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (4);
++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (5);
++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (6);
+ 
+-  /* Check Zero */
+-  MPFR_SET_ZERO (x);
+-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check INF */
++      mpfr_set_inf (x, 1);
++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (7);
++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (8);
++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (9);
++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (10);
++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (11);
++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (12);
+ 
+-  /* Check small op */
+-  mpfr_set_str1 (x, "1@-1");
+-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check Zero */
++      MPFR_SET_ZERO (x);
++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (13);
++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (14);
++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (15);
++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (16);
++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (17);
++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (18);
+ 
+-  /* Check 17 */
+-  mpfr_set_ui (x, 17, MPFR_RNDN);
+-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check small positive op */
++      mpfr_set_str1 (x, "1@-1");
++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (19);
++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (20);
++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (21);
++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (22);
++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (23);
++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (24);
+ 
+-  /* Check all other values */
+-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+-  mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
+-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
+-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check 17 */
++      mpfr_set_ui (x, 17, MPFR_RNDN);
++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (25);
++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (26);
++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (27);
++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (28);
++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (29);
++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (30);
+ 
+-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check all other values */
++      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
++      mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (31);
++      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (32);
++      mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
++      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (33);
++      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (34);
++      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (35);
++      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (36);
++      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (37);
+ 
+-  mpfr_set_si (x, 1, MPFR_RNDN);
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
++      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
++      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (38);
++      mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
++      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++        ERROR1 (39);
++      mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
++      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (40);
++      mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (41);
++      mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
++      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (42);
++      mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (43);
+ 
+-  /* Check negative value */
+-  mpfr_set_si (x, -1, MPFR_RNDN);
+-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
+-    ERROR1;
++      mpfr_set_si (x, 1, MPFR_RNDN);
++      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++        ERROR1 (44);
++      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++        ERROR1 (45);
++
++      /* Check negative op */
++      for (i = 1; i <= 4; i++)
++        {
++          int inv;
++
++          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
++          mpfr_rint (y, x, (mpfr_rnd_t) r);
++          inv = MPFR_NOTZERO (y);
++          if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
++            ERROR1 (46);
++          if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
++            ERROR1 (47);
++          if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
++            ERROR1 (48);
++          if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
++            ERROR1 (49);
++          if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
++            ERROR1 (50);
++          if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
++            ERROR1 (51);
++        }
++    }
+ 
+   mpfr_clear (x);
++  mpfr_clear (y);
+ 
+   check_intmax ();
+ 
+@@ -189,85 +210,98 @@
+   return 0;
+ }
+ 
+-static void check_intmax (void)
++static void
++check_intmax (void)
+ {
+ #ifdef _MPFR_H_HAVE_INTMAX_T
+-  mpfr_t x;
++  mpfr_t x, y;
++  int i, r;
+ 
+-  mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT);
++  mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
++  mpfr_init2 (y, 8);
+ 
+-  /* Check NAN */
+-  mpfr_set_nan (x);
+-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR1;
++  RND_LOOP (r)
++    {
++      /* Check NAN */
++      mpfr_set_nan (x);
++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (52);
++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (53);
+ 
+-  /* Check INF */
+-  mpfr_set_inf (x, 1);
+-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check INF */
++      mpfr_set_inf (x, 1);
++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (54);
++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (55);
+ 
+-  /* Check Zero */
+-  MPFR_SET_ZERO (x);
+-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check Zero */
++      MPFR_SET_ZERO (x);
++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (56);
++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (57);
+ 
+-  /* Check small op */
+-  mpfr_set_str1 (x, "1@-1");
+-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check positive small op */
++      mpfr_set_str1 (x, "1@-1");
++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (58);
++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (59);
+ 
+-  /* Check 17 */
+-  mpfr_set_ui (x, 17, MPFR_RNDN);
+-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
++      /* Check 17 */
++      mpfr_set_ui (x, 17, MPFR_RNDN);
++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (60);
++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (61);
+ 
+-  /* Check hugest */
+-  mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
+-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR1;
+-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check hugest */
++      mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (62);
++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (63);
+ 
+-  /* Check all other values */
+-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
+-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR1;
+-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
+-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR1;
+-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  mpfr_sub_ui (x, x, 1, MPFR_RNDN);
+-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check all other values */
++      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
++      mpfr_add_ui (x, x, 1, MPFR_RNDN);
++      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (64);
++      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
++      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (65);
++      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
++      mpfr_add_ui (x, x, 1, MPFR_RNDN);
++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (66);
++      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (67);
++      mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
++      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (68);
++      mpfr_sub_ui (x, x, 1, MPFR_RNDN);
++      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++        ERROR1 (69);
+ 
+-  /* Check negative value */
+-  mpfr_set_si (x, -1, MPFR_RNDN);
+-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
+-    ERROR2;
+-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
+-    ERROR1;
++      /* Check negative op */
++      for (i = 1; i <= 4; i++)
++        {
++          int inv;
++
++          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
++          mpfr_rint (y, x, (mpfr_rnd_t) r);
++          inv = MPFR_NOTZERO (y);
++          if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
++            ERROR1 (70);
++          if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
++            ERROR1 (71);
++        }
++    }
+ 
+   mpfr_clear (x);
++  mpfr_clear (y);
+ #endif
+ }
+-
+diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
+--- mpfr-3.1.2-a/PATCHES	2013-10-09 13:34:21.000000000 +0000
++++ mpfr-3.1.2-b/PATCHES	2013-10-09 13:34:21.000000000 +0000
+@@ -0,0 +1 @@
++clang-divby0
+diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
+--- mpfr-3.1.2-a/VERSION	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/VERSION	2013-10-09 13:34:21.000000000 +0000
+@@ -1 +1 @@
+-3.1.2-p2
++3.1.2-p3
+diff -Naurd mpfr-3.1.2-a/src/mpfr-impl.h mpfr-3.1.2-b/src/mpfr-impl.h
+--- mpfr-3.1.2-a/src/mpfr-impl.h	2013-03-13 15:37:36.000000000 +0000
++++ mpfr-3.1.2-b/src/mpfr-impl.h	2013-10-09 13:34:21.000000000 +0000
+@@ -468,8 +468,16 @@
+ #define MPFR_LIMBS_PER_FLT ((IEEE_FLT_MANT_DIG-1)/GMP_NUMB_BITS+1)
+ 
+ /* Visual C++ doesn't support +1.0/0.0, -1.0/0.0 and 0.0/0.0
+-   at compile time. */
+-#if defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)
++   at compile time.
++   Clang with -fsanitize=undefined is a bit similar due to a bug:
++     http://llvm.org/bugs/show_bug.cgi?id=17381
++   but even without its sanitizer, it may be better to use the
++   double_zero version until IEEE 754 division by zero is properly
++   supported:
++     http://llvm.org/bugs/show_bug.cgi?id=17000
++*/
++#if (defined(_MSC_VER) && defined(_WIN32) && (_MSC_VER >= 1200)) || \
++    defined(__clang__)
+ static double double_zero = 0.0;
+ # define DBL_NAN (double_zero/double_zero)
+ # define DBL_POS_INF ((double) 1.0/double_zero)
+@@ -501,6 +509,8 @@
+    (with Xcode 2.4.1, i.e. the latest one). */
+ #define LVALUE(x) (&(x) == &(x) || &(x) != &(x))
+ #define DOUBLE_ISINF(x) (LVALUE(x) && ((x) > DBL_MAX || (x) < -DBL_MAX))
++/* The DOUBLE_ISNAN(x) macro is also valid on long double x
++   (assuming that the compiler isn't too broken). */
+ #ifdef MPFR_NANISNAN
+ /* Avoid MIPSpro / IRIX64 / gcc -ffast-math (incorrect) optimizations.
+    The + must not be replaced by a ||. With gcc -ffast-math, NaN is
+diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
+--- mpfr-3.1.2-a/src/mpfr.h	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/src/mpfr.h	2013-10-09 13:34:21.000000000 +0000
+@@ -27,7 +27,7 @@
+ #define MPFR_VERSION_MAJOR 3
+ #define MPFR_VERSION_MINOR 1
+ #define MPFR_VERSION_PATCHLEVEL 2
+-#define MPFR_VERSION_STRING "3.1.2-p2"
++#define MPFR_VERSION_STRING "3.1.2-p3"
+ 
+ /* Macros dealing with MPFR VERSION */
+ #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
+diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
+--- mpfr-3.1.2-a/src/version.c	2013-09-26 10:52:52.000000000 +0000
++++ mpfr-3.1.2-b/src/version.c	2013-10-09 13:34:21.000000000 +0000
+@@ -25,5 +25,5 @@
+ const char *
+ mpfr_get_version (void)
+ {
+-  return "3.1.2-p2";
++  return "3.1.2-p3";
+ }
+diff -Naurd mpfr-3.1.2-a/tests/tget_flt.c mpfr-3.1.2-b/tests/tget_flt.c
+--- mpfr-3.1.2-a/tests/tget_flt.c	2013-03-13 15:37:44.000000000 +0000
++++ mpfr-3.1.2-b/tests/tget_flt.c	2013-10-09 13:34:21.000000000 +0000
+@@ -28,9 +28,17 @@
+ main (void)
+ {
+   mpfr_t x, y;
+-  float f, g, infp;
++  float f, g;
+   int i;
++#if !defined(MPFR_ERRDIVZERO)
++  float infp;
++#endif
++
++  tests_start_mpfr ();
+ 
++#if !defined(MPFR_ERRDIVZERO)
++  /* The definition of DBL_POS_INF involves a division by 0. This makes
++     "clang -O2 -fsanitize=undefined -fno-sanitize-recover" fail. */
+   infp = (float) DBL_POS_INF;
+   if (infp * 0.5 != infp)
+     {
+@@ -38,8 +46,7 @@
+       fprintf (stderr, "(this is probably a compiler bug, please report)\n");
+       exit (1);
+     }
+-
+-  tests_start_mpfr ();
++#endif
+ 
+   mpfr_init2 (x, 24);
+   mpfr_init2 (y, 24);
+@@ -353,6 +360,7 @@
+       printf ("expected %.8e, got %.8e\n", g, f);
+       exit (1);
+     }
++#if !defined(MPFR_ERRDIVZERO)
+   f = mpfr_get_flt (x, MPFR_RNDN); /* first round to 2^128 (even rule),
+                                       thus we should get +Inf */
+   g = infp;
+@@ -376,6 +384,7 @@
+       printf ("expected %.8e, got %.8e\n", g, f);
+       exit (1);
+     }
++#endif
+ 
+   mpfr_clear (x);
+   mpfr_clear (y);
+diff -Naurd mpfr-3.1.2-a/tests/tset_ld.c mpfr-3.1.2-b/tests/tset_ld.c
+--- mpfr-3.1.2-a/tests/tset_ld.c	2013-03-13 15:37:44.000000000 +0000
++++ mpfr-3.1.2-b/tests/tset_ld.c	2013-10-09 13:34:21.000000000 +0000
+@@ -47,8 +47,11 @@
+ static int
+ Isnan_ld (long double d)
+ {
+-  double e = (double) d;
+-  if (DOUBLE_ISNAN (e))
++  /* Do not convert d to double as this can give an overflow, which
++     may confuse compilers without IEEE 754 support (such as clang
++     -fsanitize=undefined), or trigger a trap if enabled.
++     The DOUBLE_ISNAN macro should work fine on long double. */
++  if (DOUBLE_ISNAN (d))
+     return 1;
+   LONGDOUBLE_NAN_ACTION (d, goto yes);
+   return 0;