bug-gnulib
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: lib/regex_internal.h on 1.4.11


From: Bruno Haible
Subject: Re: lib/regex_internal.h on 1.4.11
Date: Fri, 1 Aug 2008 11:30:06 +0200
User-agent: KMail/1.9.1

Jonathan C. Patschke wrote:
> That fixes the problem in test-frexp and test-strtod, but not test-frexpl
> (which still fails the (mantissa == x) assertion).

Thanks. I'm applying the patch below, assuming that if the compiler
confuses -0.0 with 0.0, it also confuses -0.0L with 0.0, and -0.0f with 0.0f.

> verifying literal negative 0.0 looks to be
> the entire point of that assertion.

The point of the signbit test is to verify our signbit replacement. If the
compiler has a problem with -0.0 literals, that's a problem we cannot fix in
gnulib.

Bruno


2008-08-01  Bruno Haible  <address@hidden>

        Work around bug of HP-UX 10.20 cc with -0.0 literal.
        * tests/test-isnanf.h (zero): New variable.
        (main): Avoid literal -0.0f.
        * tests/test-isnand.h (zero): New variable.
        (main): Avoid literal -0.0.
        * tests/test-isnanl.h (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-isnan.c (zerof, zerod, zerol): New variables.
        (test_float, test_double, test_long_double): Avoid literals -0.0f,
        -0.0, -0.0L.
        * tests/test-signbit.c (test_signbitf): Avoid literal -0.0f.
        (test_signbitd): Avoid literal -0.0.
        (test_signbitl): Avoid literal -0.0L.
        * tests/test-ceilf1.c (zero): New variable.
        (main): Avoid literal -0.0f.
        * tests/test-ceill.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-floorf1.c (zero): New variable.
        (main): Avoid literal -0.0f.
        * tests/test-floorl.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-roundf1.c (zero): New variable.
        (main): Avoid literal -0.0f.
        * tests/test-round1.c (zero): New variable.
        (main): Avoid literal -0.0.
        * tests/test-roundl.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-truncf1.c (zero): New variable.
        (main): Avoid literal -0.0f.
        * tests/test-trunc1.c (zero): New variable.
        (main): Avoid literal -0.0.
        * tests/test-truncl.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-frexp.c (zero): New variable.
        (main): Avoid literal -0.0.
        * tests/test-frexpl.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-ldexpl.c (zero): New variable.
        (main): Avoid literal -0.0L.
        * tests/test-snprintf-posix.h (have_minus_zero): Avoid literal -0.0.
        (zerod, zerol): New variables.
        (test_function): Avoid literals -0.0, -0.0L.
        * tests/test-sprintf-posix.h (have_minus_zero): Avoid literal -0.0.
        (zerod, zerol): New variables.
        (test_function): Avoid literals -0.0, -0.0L.
        * tests/test-vasnprintf-posix.c (have_minus_zero): Avoid literal -0.0.
        (zerod, zerol): New variables.
        (test_function): Avoid literals -0.0, -0.0L.
        * tests/test-vasprintf-posix.c (have_minus_zero): Avoid literal -0.0.
        (zerod, zerol): New variables.
        (test_function): Avoid literals -0.0, -0.0L.
        * tests/test-strtod.c (zero): New variable.
        (main): Avoid literal -0.0.
        Reported by Jonathan C. Patschke <address@hidden>.

*** tests/test-ceilf1.c.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-ceilf1.c 2008-08-01 01:08:19.000000000 +0200
***************
*** 38,49 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (ceilf (0.0f) == 0.0f);
!   ASSERT (ceilf (-0.0f) == 0.0f);
    /* Positive numbers.  */
    ASSERT (ceilf (0.3f) == 1.0f);
    ASSERT (ceilf (0.7f) == 1.0f);
--- 38,53 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zero = 0.0f;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (ceilf (0.0f) == 0.0f);
!   ASSERT (ceilf (-zero) == 0.0f);
    /* Positive numbers.  */
    ASSERT (ceilf (0.3f) == 1.0f);
    ASSERT (ceilf (0.7f) == 1.0f);
*** tests/test-ceill.c.orig     2008-08-01 09:32:20.000000000 +0200
--- tests/test-ceill.c  2008-08-01 01:08:37.000000000 +0200
***************
*** 38,43 ****
--- 38,47 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 47,53 ****
  
    /* Zero.  */
    ASSERT (ceill (0.0L) == 0.0L);
!   ASSERT (ceill (-0.0L) == 0.0L);
    /* Positive numbers.  */
    ASSERT (ceill (0.3L) == 1.0L);
    ASSERT (ceill (0.7L) == 1.0L);
--- 51,57 ----
  
    /* Zero.  */
    ASSERT (ceill (0.0L) == 0.0L);
!   ASSERT (ceill (-zero) == 0.0L);
    /* Positive numbers.  */
    ASSERT (ceill (0.3L) == 1.0L);
    ASSERT (ceill (0.7L) == 1.0L);
*** tests/test-floorf1.c.orig   2008-08-01 09:32:20.000000000 +0200
--- tests/test-floorf1.c        2008-08-01 01:08:58.000000000 +0200
***************
*** 38,49 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (floorf (0.0f) == 0.0f);
!   ASSERT (floorf (-0.0f) == 0.0f);
    /* Positive numbers.  */
    ASSERT (floorf (0.3f) == 0.0f);
    ASSERT (floorf (0.7f) == 0.0f);
--- 38,53 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zero = 0.0f;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (floorf (0.0f) == 0.0f);
!   ASSERT (floorf (-zero) == 0.0f);
    /* Positive numbers.  */
    ASSERT (floorf (0.3f) == 0.0f);
    ASSERT (floorf (0.7f) == 0.0f);
*** tests/test-floorl.c.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-floorl.c 2008-08-01 01:09:13.000000000 +0200
***************
*** 38,43 ****
--- 38,47 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 47,53 ****
  
    /* Zero.  */
    ASSERT (floorl (0.0L) == 0.0L);
!   ASSERT (floorl (-0.0L) == 0.0L);
    /* Positive numbers.  */
    ASSERT (floorl (0.3L) == 0.0L);
    ASSERT (floorl (0.7L) == 0.0L);
--- 51,57 ----
  
    /* Zero.  */
    ASSERT (floorl (0.0L) == 0.0L);
!   ASSERT (floorl (-zero) == 0.0L);
    /* Positive numbers.  */
    ASSERT (floorl (0.3L) == 0.0L);
    ASSERT (floorl (0.7L) == 0.0L);
*** tests/test-frexp.c.orig     2008-08-01 09:32:20.000000000 +0200
--- tests/test-frexp.c  2008-08-01 01:04:11.000000000 +0200
***************
*** 44,49 ****
--- 44,53 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zero = 0.0;
+ 
  static double
  my_ldexp (double x, int d)
  {
***************
*** 102,108 ****
    { /* Negative zero.  */
      int exp = -9999;
      double mantissa;
!     x = -0.0;
      mantissa = frexp (x, &exp);
      ASSERT (exp == 0);
      ASSERT (mantissa == x);
--- 106,112 ----
    { /* Negative zero.  */
      int exp = -9999;
      double mantissa;
!     x = -zero;
      mantissa = frexp (x, &exp);
      ASSERT (exp == 0);
      ASSERT (mantissa == x);
*** tests/test-frexpl.c.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-frexpl.c 2008-08-01 01:06:57.000000000 +0200
***************
*** 57,62 ****
--- 57,66 ----
  # define MIN_NORMAL_EXP LDBL_MIN_EXP
  #endif
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  static long double
  my_ldexp (long double x, int d)
  {
***************
*** 113,119 ****
    { /* Negative zero.  */
      int exp = -9999;
      long double mantissa;
!     x = -0.0L;
      mantissa = frexpl (x, &exp);
      ASSERT (exp == 0);
      ASSERT (mantissa == x);
--- 117,123 ----
    { /* Negative zero.  */
      int exp = -9999;
      long double mantissa;
!     x = -zero;
      mantissa = frexpl (x, &exp);
      ASSERT (exp == 0);
      ASSERT (mantissa == x);
*** tests/test-isnan.c.orig     2008-08-01 09:32:20.000000000 +0200
--- tests/test-isnan.c  2008-08-01 01:12:52.000000000 +0200
***************
*** 40,45 ****
--- 40,57 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zerof = 0.0f;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zerod = 0.0;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zerol = 0.0L;
+ 
  static void
  test_float (void)
  {
***************
*** 51,57 ****
    ASSERT (!isnan (-2.718e30f));
    ASSERT (!isnan (-2.718e-30f));
    ASSERT (!isnan (0.0f));
!   ASSERT (!isnan (-0.0f));
    /* Infinite values.  */
    ASSERT (!isnan (1.0f / 0.0f));
    ASSERT (!isnan (-1.0f / 0.0f));
--- 63,69 ----
    ASSERT (!isnan (-2.718e30f));
    ASSERT (!isnan (-2.718e-30f));
    ASSERT (!isnan (0.0f));
!   ASSERT (!isnan (-zerof));
    /* Infinite values.  */
    ASSERT (!isnan (1.0f / 0.0f));
    ASSERT (!isnan (-1.0f / 0.0f));
***************
*** 91,97 ****
    ASSERT (!isnan (-2.718e30));
    ASSERT (!isnan (-2.718e-30));
    ASSERT (!isnan (0.0));
!   ASSERT (!isnan (-0.0));
    /* Infinite values.  */
    ASSERT (!isnan (1.0 / 0.0));
    ASSERT (!isnan (-1.0 / 0.0));
--- 103,109 ----
    ASSERT (!isnan (-2.718e30));
    ASSERT (!isnan (-2.718e-30));
    ASSERT (!isnan (0.0));
!   ASSERT (!isnan (-zerod));
    /* Infinite values.  */
    ASSERT (!isnan (1.0 / 0.0));
    ASSERT (!isnan (-1.0 / 0.0));
***************
*** 134,140 ****
    ASSERT (!isnan (-2.718e30L));
    ASSERT (!isnan (-2.718e-30L));
    ASSERT (!isnan (0.0L));
!   ASSERT (!isnan (-0.0L));
    /* Infinite values.  */
    ASSERT (!isnan (1.0L / 0.0L));
    ASSERT (!isnan (-1.0L / 0.0L));
--- 146,152 ----
    ASSERT (!isnan (-2.718e30L));
    ASSERT (!isnan (-2.718e-30L));
    ASSERT (!isnan (0.0L));
!   ASSERT (!isnan (-zerol));
    /* Infinite values.  */
    ASSERT (!isnan (1.0L / 0.0L));
    ASSERT (!isnan (-1.0L / 0.0L));
*** tests/test-isnand.h.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-isnand.h 2008-08-01 01:13:20.000000000 +0200
***************
*** 34,39 ****
--- 34,43 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zero = 0.0;
+ 
  int
  main ()
  {
***************
*** 45,51 ****
    ASSERT (!isnand (-2.718e30));
    ASSERT (!isnand (-2.718e-30));
    ASSERT (!isnand (0.0));
!   ASSERT (!isnand (-0.0));
    /* Infinite values.  */
    ASSERT (!isnand (1.0 / 0.0));
    ASSERT (!isnand (-1.0 / 0.0));
--- 49,55 ----
    ASSERT (!isnand (-2.718e30));
    ASSERT (!isnand (-2.718e-30));
    ASSERT (!isnand (0.0));
!   ASSERT (!isnand (-zero));
    /* Infinite values.  */
    ASSERT (!isnand (1.0 / 0.0));
    ASSERT (!isnand (-1.0 / 0.0));
*** tests/test-isnanf.h.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-isnanf.h 2008-08-01 01:13:38.000000000 +0200
***************
*** 34,39 ****
--- 34,43 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zero = 0.0f;
+ 
  int
  main ()
  {
***************
*** 45,51 ****
    ASSERT (!isnanf (-2.718e30f));
    ASSERT (!isnanf (-2.718e-30f));
    ASSERT (!isnanf (0.0f));
!   ASSERT (!isnanf (-0.0f));
    /* Infinite values.  */
    ASSERT (!isnanf (1.0f / 0.0f));
    ASSERT (!isnanf (-1.0f / 0.0f));
--- 49,55 ----
    ASSERT (!isnanf (-2.718e30f));
    ASSERT (!isnanf (-2.718e-30f));
    ASSERT (!isnanf (0.0f));
!   ASSERT (!isnanf (-zero));
    /* Infinite values.  */
    ASSERT (!isnanf (1.0f / 0.0f));
    ASSERT (!isnanf (-1.0f / 0.0f));
*** tests/test-isnanl.h.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-isnanl.h 2008-08-01 01:13:57.000000000 +0200
***************
*** 33,38 ****
--- 33,42 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 49,55 ****
    ASSERT (!isnanl (-2.718e30L));
    ASSERT (!isnanl (-2.718e-30L));
    ASSERT (!isnanl (0.0L));
!   ASSERT (!isnanl (-0.0L));
    /* Infinite values.  */
    ASSERT (!isnanl (1.0L / 0.0L));
    ASSERT (!isnanl (-1.0L / 0.0L));
--- 53,59 ----
    ASSERT (!isnanl (-2.718e30L));
    ASSERT (!isnanl (-2.718e-30L));
    ASSERT (!isnanl (0.0L));
!   ASSERT (!isnanl (-zero));
    /* Infinite values.  */
    ASSERT (!isnanl (1.0L / 0.0L));
    ASSERT (!isnanl (-1.0L / 0.0L));
*** tests/test-ldexpl.c.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-ldexpl.c 2008-08-01 01:07:25.000000000 +0200
***************
*** 39,44 ****
--- 39,48 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 78,84 ****
    }
  
    { /* Negative zero.  */
!     x = -0.0L;
      y = ldexpl (x, 0); ASSERT (y == x); ASSERT (signbit (x));
      y = ldexpl (x, 5); ASSERT (y == x); ASSERT (signbit (x));
      y = ldexpl (x, -5); ASSERT (y == x); ASSERT (signbit (x));
--- 82,88 ----
    }
  
    { /* Negative zero.  */
!     x = -zero;
      y = ldexpl (x, 0); ASSERT (y == x); ASSERT (signbit (x));
      y = ldexpl (x, 5); ASSERT (y == x); ASSERT (signbit (x));
      y = ldexpl (x, -5); ASSERT (y == x); ASSERT (signbit (x));
*** tests/test-round1.c.orig    2008-08-01 09:32:20.000000000 +0200
--- tests/test-round1.c 2008-08-01 01:09:33.000000000 +0200
***************
*** 40,51 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (round (0.0) == 0.0);
!   ASSERT (round (-0.0) == 0.0);
    /* Positive numbers.  */
    ASSERT (round (0.3) == 0.0);
    ASSERT (round (0.5) == 1.0);
--- 40,55 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zero = 0.0;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (round (0.0) == 0.0);
!   ASSERT (round (-zero) == 0.0);
    /* Positive numbers.  */
    ASSERT (round (0.3) == 0.0);
    ASSERT (round (0.5) == 1.0);
*** tests/test-roundf1.c.orig   2008-08-01 09:32:20.000000000 +0200
--- tests/test-roundf1.c        2008-08-01 01:09:48.000000000 +0200
***************
*** 40,51 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (roundf (0.0f) == 0.0f);
!   ASSERT (roundf (-0.0f) == 0.0f);
    /* Positive numbers.  */
    ASSERT (roundf (0.3f) == 0.0f);
    ASSERT (roundf (0.5f) == 1.0f);
--- 40,55 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zero = 0.0f;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (roundf (0.0f) == 0.0f);
!   ASSERT (roundf (-zero) == 0.0f);
    /* Positive numbers.  */
    ASSERT (roundf (0.3f) == 0.0f);
    ASSERT (roundf (0.5f) == 1.0f);
*** tests/test-roundl.c.orig    2008-08-01 09:32:21.000000000 +0200
--- tests/test-roundl.c 2008-08-01 01:10:08.000000000 +0200
***************
*** 40,45 ****
--- 40,49 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 49,55 ****
  
    /* Zero.  */
    ASSERT (roundl (0.0L) == 0.0L);
!   ASSERT (roundl (-0.0L) == 0.0L);
    /* Positive numbers.  */
    ASSERT (roundl (0.3L) == 0.0L);
    ASSERT (roundl (0.5L) == 1.0L);
--- 53,59 ----
  
    /* Zero.  */
    ASSERT (roundl (0.0L) == 0.0L);
!   ASSERT (roundl (-zero) == 0.0L);
    /* Positive numbers.  */
    ASSERT (roundl (0.3L) == 0.0L);
    ASSERT (roundl (0.5L) == 1.0L);
*** tests/test-signbit.c.orig   2008-08-01 09:32:21.000000000 +0200
--- tests/test-signbit.c        2008-08-01 01:15:33.000000000 +0200
***************
*** 56,64 ****
    /* Zeros.  */
    ASSERT (!signbit (0.0f));
    if (1.0f / -zerof < 0)
!     ASSERT (signbit (-0.0f));
    else
!     ASSERT (!signbit (-0.0f));
    /* Infinite values.  */
    ASSERT (!signbit (1.0f / 0.0f));
    ASSERT (signbit (-1.0f / 0.0f));
--- 56,64 ----
    /* Zeros.  */
    ASSERT (!signbit (0.0f));
    if (1.0f / -zerof < 0)
!     ASSERT (signbit (-zerof));
    else
!     ASSERT (!signbit (-zerof));
    /* Infinite values.  */
    ASSERT (!signbit (1.0f / 0.0f));
    ASSERT (signbit (-1.0f / 0.0f));
***************
*** 101,109 ****
    /* Zeros.  */
    ASSERT (!signbit (0.0));
    if (1.0 / -zerod < 0)
!     ASSERT (signbit (-0.0));
    else
!     ASSERT (!signbit (-0.0));
    /* Infinite values.  */
    ASSERT (!signbit (1.0 / 0.0));
    ASSERT (signbit (-1.0 / 0.0));
--- 101,109 ----
    /* Zeros.  */
    ASSERT (!signbit (0.0));
    if (1.0 / -zerod < 0)
!     ASSERT (signbit (-zerod));
    else
!     ASSERT (!signbit (-zerod));
    /* Infinite values.  */
    ASSERT (!signbit (1.0 / 0.0));
    ASSERT (signbit (-1.0 / 0.0));
***************
*** 144,152 ****
    /* Zeros.  */
    ASSERT (!signbit (0.0L));
    if (1.0L / minus_zerol < 0)
!     ASSERT (signbit (-0.0L));
    else
!     ASSERT (!signbit (-0.0L));
    /* Infinite values.  */
    ASSERT (!signbit (1.0L / 0.0L));
    ASSERT (signbit (-1.0L / 0.0L));
--- 144,152 ----
    /* Zeros.  */
    ASSERT (!signbit (0.0L));
    if (1.0L / minus_zerol < 0)
!     ASSERT (signbit (-zerol));
    else
!     ASSERT (!signbit (-zerol));
    /* Infinite values.  */
    ASSERT (!signbit (1.0L / 0.0L));
    ASSERT (signbit (-1.0L / 0.0L));
*** tests/test-snprintf-posix.h.orig    2008-08-01 09:32:21.000000000 +0200
--- tests/test-snprintf-posix.h 2008-08-01 01:18:46.000000000 +0200
***************
*** 23,32 ****
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   static double minus_zero = -0.0;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
--- 23,40 ----
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   double minus_zero = - plus_zero;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zerod = 0.0;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zerol = 0.0L;
+ 
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
***************
*** 172,178 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%a %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
--- 180,186 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%a %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 436,442 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%La %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
--- 444,450 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%La %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 881,887 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%f %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 889,895 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%f %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1144,1150 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Lf %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1152,1158 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Lf %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1407,1413 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%F %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1415,1421 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%F %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1517,1523 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%LF %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1525,1531 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%LF %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1731,1737 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%e %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
              || strcmp (result, "-0.000000e+000 33") == 0);
--- 1739,1745 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%e %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
              || strcmp (result, "-0.000000e+000 33") == 0);
***************
*** 2008,2014 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Le %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
      ASSERT (retval == strlen (result));
--- 2016,2022 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Le %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 2372,2378 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%g %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
--- 2380,2386 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%g %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 2639,2645 ****
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Lg %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
--- 2647,2653 ----
    { /* Negative zero.  */
      char result[100];
      int retval =
!       my_snprintf (result, sizeof (result), "%Lg %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
*** tests/test-sprintf-posix.h.orig     2008-08-01 09:32:21.000000000 +0200
--- tests/test-sprintf-posix.h  2008-08-01 01:23:00.000000000 +0200
***************
*** 23,32 ****
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   static double minus_zero = -0.0;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
--- 23,40 ----
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   double minus_zero = - plus_zero;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zerod = 0.0;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zerol = 0.0L;
+ 
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
***************
*** 158,164 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
--- 166,172 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%a %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 422,428 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
--- 430,436 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%La %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 867,873 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 875,881 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%f %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1124,1130 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1132,1138 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Lf %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1381,1387 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1389,1395 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%F %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1491,1497 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
--- 1499,1505 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%LF %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 1705,1711 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
              || strcmp (result, "-0.000000e+000 33") == 0);
--- 1713,1719 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%e %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
              || strcmp (result, "-0.000000e+000 33") == 0);
***************
*** 1982,1988 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
      ASSERT (retval == strlen (result));
--- 1990,1996 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Le %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 2346,2352 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
--- 2354,2360 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%g %d", -zerod, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
***************
*** 2613,2619 ****
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
--- 2621,2627 ----
    { /* Negative zero.  */
      char result[1000];
      int retval =
!       my_sprintf (result, "%Lg %d", -zerol, 33, 44, 55);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
      ASSERT (retval == strlen (result));
*** tests/test-strtod.c.orig    2008-08-01 09:32:21.000000000 +0200
--- tests/test-strtod.c 2008-08-01 01:11:55.000000000 +0200
***************
*** 42,47 ****
--- 42,51 ----
  /* Avoid requiring -lm just for fabs.  */
  #define FABS(d) ((d) < 0.0 ? -(d) : (d))
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zero = 0.0;
+ 
  int
  main ()
  {
***************
*** 317,323 ****
      errno = 0;
      result = strtod (input, &ptr);
      ASSERT (result == 0.0);
!     ASSERT (!!signbit (result) == !!signbit (-0.0)); /* IRIX 6.5, OSF/1 4.0 */
      ASSERT (ptr == input + 2);
      ASSERT (errno == 0);
    }
--- 321,327 ----
      errno = 0;
      result = strtod (input, &ptr);
      ASSERT (result == 0.0);
!     ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 
*/
      ASSERT (ptr == input + 2);
      ASSERT (errno == 0);
    }
***************
*** 412,418 ****
      errno = 0;
      result = strtod (input, &ptr);
      ASSERT (result == 0.0);
!     ASSERT (!!signbit (result) == !!signbit (-0.0)); /* MacOS X 10.3, FreeBSD 
6.2, IRIX 6.5, OSF/1 4.0 */
      ASSERT (ptr == input + 2);          /* glibc-2.3.6, MacOS X 10.3, FreeBSD 
6.2 */
      ASSERT (errno == 0);
    }
--- 416,422 ----
      errno = 0;
      result = strtod (input, &ptr);
      ASSERT (result == 0.0);
!     ASSERT (!!signbit (result) == !!signbit (-zero)); /* MacOS X 10.3, 
FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
      ASSERT (ptr == input + 2);          /* glibc-2.3.6, MacOS X 10.3, FreeBSD 
6.2 */
      ASSERT (errno == 0);
    }
***************
*** 537,543 ****
         0 on negative underflow, even though quality of implementation
         demands preserving the sign.  Disable this test until fixed
         glibc is more prevalent.  */
!     ASSERT (!!signbit (result) == !!signbit (-0.0)); /* glibc-2.3.6, mingw */
  #endif
      ASSERT (ptr == input + 10);
      ASSERT (errno == ERANGE);
--- 541,547 ----
         0 on negative underflow, even though quality of implementation
         demands preserving the sign.  Disable this test until fixed
         glibc is more prevalent.  */
!     ASSERT (!!signbit (result) == !!signbit (-zero)); /* glibc-2.3.6, mingw */
  #endif
      ASSERT (ptr == input + 10);
      ASSERT (errno == ERANGE);
***************
*** 906,912 ****
        errno = 0;
        result = strtod (input, &ptr);
        ASSERT (result == 0.0);
!       ASSERT (!!signbit (result) == !!signbit (-0.0)); /* IRIX 6.5, OSF/1 4.0 
*/
        ASSERT (ptr == input + m);
        ASSERT (errno == 0);
        }
--- 910,916 ----
        errno = 0;
        result = strtod (input, &ptr);
        ASSERT (result == 0.0);
!       ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 
4.0 */
        ASSERT (ptr == input + m);
        ASSERT (errno == 0);
        }
*** tests/test-trunc1.c.orig    2008-08-01 09:32:21.000000000 +0200
--- tests/test-trunc1.c 2008-08-01 01:10:25.000000000 +0200
***************
*** 38,49 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (trunc (0.0) == 0.0);
!   ASSERT (trunc (-0.0) == 0.0);
    /* Positive numbers.  */
    ASSERT (trunc (0.3) == 0.0);
    ASSERT (trunc (0.7) == 0.0);
--- 38,53 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zero = 0.0;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (trunc (0.0) == 0.0);
!   ASSERT (trunc (-zero) == 0.0);
    /* Positive numbers.  */
    ASSERT (trunc (0.3) == 0.0);
    ASSERT (trunc (0.7) == 0.0);
*** tests/test-truncf1.c.orig   2008-08-01 09:32:21.000000000 +0200
--- tests/test-truncf1.c        2008-08-01 01:10:44.000000000 +0200
***************
*** 38,49 ****
      }                                                                      \
    while (0)
  
  int
  main ()
  {
    /* Zero.  */
    ASSERT (truncf (0.0f) == 0.0f);
!   ASSERT (truncf (-0.0f) == 0.0f);
    /* Positive numbers.  */
    ASSERT (truncf (0.3f) == 0.0f);
    ASSERT (truncf (0.7f) == 0.0f);
--- 38,53 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0f.
+    So we use -zero instead.  */
+ float zero = 0.0f;
+ 
  int
  main ()
  {
    /* Zero.  */
    ASSERT (truncf (0.0f) == 0.0f);
!   ASSERT (truncf (-zero) == 0.0f);
    /* Positive numbers.  */
    ASSERT (truncf (0.3f) == 0.0f);
    ASSERT (truncf (0.7f) == 0.0f);
*** tests/test-truncl.c.orig    2008-08-01 09:32:21.000000000 +0200
--- tests/test-truncl.c 2008-08-01 01:10:59.000000000 +0200
***************
*** 38,43 ****
--- 38,47 ----
      }                                                                      \
    while (0)
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zero = 0.0L;
+ 
  int
  main ()
  {
***************
*** 47,53 ****
  
    /* Zero.  */
    ASSERT (truncl (0.0L) == 0.0L);
!   ASSERT (truncl (-0.0L) == 0.0L);
    /* Positive numbers.  */
    ASSERT (truncl (0.3L) == 0.0L);
    ASSERT (truncl (0.7L) == 0.0L);
--- 51,57 ----
  
    /* Zero.  */
    ASSERT (truncl (0.0L) == 0.0L);
!   ASSERT (truncl (-zero) == 0.0L);
    /* Positive numbers.  */
    ASSERT (truncl (0.3L) == 0.0L);
    ASSERT (truncl (0.7L) == 0.0L);
*** tests/test-vasnprintf-posix.c.orig  2008-08-01 09:32:21.000000000 +0200
--- tests/test-vasnprintf-posix.c       2008-08-01 01:22:43.000000000 +0200
***************
*** 48,57 ****
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   static double minus_zero = -0.0;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
--- 48,65 ----
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   double minus_zero = - plus_zero;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zerod = 0.0;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zerol = 0.0L;
+ 
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
***************
*** 217,223 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%a %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
--- 225,231 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%a %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
***************
*** 531,537 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%La %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
--- 539,545 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%La %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
***************
*** 1044,1050 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%f %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1052,1058 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%f %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1343,1349 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Lf %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1351,1357 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Lf %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1654,1660 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%F %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1662,1668 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%F %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1790,1796 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%LF %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1798,1804 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%LF %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 2031,2037 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%e %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
--- 2039,2045 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%e %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
***************
*** 2352,2358 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Le %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
--- 2360,2366 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Le %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
***************
*** 2774,2780 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%g %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
--- 2782,2788 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%g %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
***************
*** 3085,3091 ****
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Lg %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
--- 3093,3099 ----
    { /* Negative zero.  */
      size_t length;
      char *result =
!       my_asnprintf (NULL, &length, "%Lg %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
*** tests/test-vasprintf-posix.c.orig   2008-08-01 09:32:21.000000000 +0200
--- tests/test-vasprintf-posix.c        2008-08-01 01:22:25.000000000 +0200
***************
*** 48,57 ****
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   static double minus_zero = -0.0;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
--- 48,65 ----
  have_minus_zero ()
  {
    static double plus_zero = 0.0;
!   double minus_zero = - plus_zero;
    return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
  }
  
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
+    So we use -zero instead.  */
+ double zerod = 0.0;
+ 
+ /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0L.
+    So we use -zero instead.  */
+ long double zerol = 0.0L;
+ 
  /* Representation of an 80-bit 'long double' as an initializer for a sequence
     of 'unsigned int' words.  */
  #ifdef WORDS_BIGENDIAN
***************
*** 198,204 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
--- 206,212 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%a %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
***************
*** 512,518 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
--- 520,526 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%La %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0x0p+0 33") == 0);
***************
*** 1025,1031 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%f %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1033,1039 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%f %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1324,1330 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Lf %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1332,1338 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Lf %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1635,1641 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%F %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1643,1649 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%F %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 1771,1777 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%LF %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
--- 1779,1785 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%LF %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000 33") == 0);
***************
*** 2012,2018 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%e %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
--- 2020,2026 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%e %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0
***************
*** 2333,2339 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Le %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
--- 2341,2347 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Le %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
***************
*** 2755,2761 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%g %d", -0.0, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
--- 2763,2769 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%g %d", -zerod, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
***************
*** 3066,3072 ****
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Lg %d", -0.0L, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);
--- 3074,3080 ----
    { /* Negative zero.  */
      char *result;
      int retval =
!       my_asprintf (&result, "%Lg %d", -zerol, 33, 44, 55);
      ASSERT (result != NULL);
      if (have_minus_zero ())
        ASSERT (strcmp (result, "-0 33") == 0);




reply via email to

[Prev in Thread] Current Thread [Next in Thread]