Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/trionan.c

 /*************************************************************************
  *
  * $Id$
  *
  * Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
@@ skipping 243 matching lines @@
 
    @return Floating-point representation of positive infinity.
 */
 TRIO_PUBLIC double
 trio_pinf(TRIO_NOARGS)
 {
   /* Cache the result */
   static double result = 0.0;
 
   if (result == 0.0) {
-    
+
 #if defined(INFINITY) && defined(__STDC_IEC_559__)
     result = (double)INFINITY;
 
 #elif defined(USE_IEEE_754)
     result = trio_make_double(ieee_754_infinity_array);
 
 #else
     /*
      * If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used
      * as infinity. Otherwise we have to resort to an overflow
      * operation to generate infinity.
      */
 # if defined(TRIO_PLATFORM_UNIX)
     void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
 # endif
 
     result = HUGE_VAL;
     if (HUGE_VAL == DBL_MAX) {
       /* Force overflow */
       result += HUGE_VAL;
     }
-    
+
 # if defined(TRIO_PLATFORM_UNIX)
     signal(SIGFPE, signal_handler);
 # endif
 
 #endif
   }
   return result;
 }
 
 /**
@@ skipping 22 matching lines @@
 
    @return Floating-point representation of NaN.
 */
 TRIO_PUBLIC double
 trio_nan(TRIO_NOARGS)
 {
   /* Cache the result */
   static double result = 0.0;
 
   if (result == 0.0) {
-    
+
 #if defined(TRIO_COMPILER_SUPPORTS_C99)
     result = nan("");
 
 #elif defined(NAN) && defined(__STDC_IEC_559__)
     result = (double)NAN;
-  
+
 #elif defined(USE_IEEE_754)
     result = trio_make_double(ieee_754_qnan_array);
 
 #else
     /*
      * There are several ways to generate NaN. The one used here is
      * to divide infinity by infinity. I would have preferred to add
      * negative infinity to positive infinity, but that yields wrong
      * result (infinity) on FreeBSD.
      *
      * This may fail if the hardware does not support NaN, or if
      * the Invalid Operation floating-point exception is unmasked.
      */
 # if defined(TRIO_PLATFORM_UNIX)
     void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
 # endif
-    
+
     result = trio_pinf() / trio_pinf();
-    
+
 # if defined(TRIO_PLATFORM_UNIX)
     signal(SIGFPE, signal_handler);
 # endif
-    
+
 #endif
   }
   return result;
 }
 
 /**
    Check for NaN.
 
    @param number An arbitrary floating-point number.
    @return Boolean value indicating whether or not the number is a NaN.
 */
 TRIO_PUBLIC int
 trio_isnan
 TRIO_ARGS1((number),
            double number)
 {
 #if (defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isnan)) \
  || defined(TRIO_COMPILER_SUPPORTS_UNIX95)
   /*
    * C99 defines isnan() as a macro. UNIX95 defines isnan() as a
    * function. This function was already present in XPG4, but this
    * is a bit tricky to detect with compiler defines, so we choose
    * the conservative approach and only use it for UNIX95.
    */
   return isnan(number);
-  
+
 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
   /*
    * Microsoft Visual C++ and Borland C++ Builder have an _isnan()
    * function.
    */
   return _isnan(number) ? TRIO_TRUE : TRIO_FALSE;
 
 #elif defined(USE_IEEE_754)
   /*
    * Examine IEEE 754 bit-pattern. A NaN must have a special exponent
    * pattern, and a non-empty mantissa.
    */
   int has_mantissa;
   int is_special_quantity;
 
   is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
-  
+
   return (is_special_quantity && has_mantissa);
-  
+
 #else
   /*
    * Fallback solution
    */
   int status;
   double integral, fraction;
-  
+
 # if defined(TRIO_PLATFORM_UNIX)
   void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
 # endif
-  
+
   status = (/*
              * NaN is the only number which does not compare to itself
              */
             ((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) ||
             /*
              * Fallback solution if NaN compares to NaN
              */
             ((number != 0.0) &&
              (fraction = modf(number, &integral),
               integral == fraction)));
-  
+
 # if defined(TRIO_PLATFORM_UNIX)
   signal(SIGFPE, signal_handler);
 # endif
-  
+
   return status;
-  
+
 #endif
 }
 
 /**
    Check for infinity.
 
    @param number An arbitrary floating-point number.
    @return 1 if positive infinity, -1 if negative infinity, 0 otherwise.
 */
 TRIO_PUBLIC int
@@ skipping 10 matching lines @@
           ? 1
           : ((fp_class(number) == FP_NEG_INF) ? -1 : 0));
 
 #elif defined(isinf)
   /*
    * C99 defines isinf() as a macro.
    */
   return isinf(number)
     ? ((number > 0.0) ? 1 : -1)
     : 0;
-  
+
 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
   /*
    * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
    * function that can be used to detect infinity.
    */
   return ((_fpclass(number) == _FPCLASS_PINF)
           ? 1
           : ((_fpclass(number) == _FPCLASS_NINF) ? -1 : 0));
 
 #elif defined(USE_IEEE_754)
   /*
    * Examine IEEE 754 bit-pattern. Infinity must have a special exponent
    * pattern, and an empty mantissa.
    */
   int has_mantissa;
   int is_special_quantity;
 
   is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
-  
+
   return (is_special_quantity && !has_mantissa)
     ? ((number < 0.0) ? -1 : 1)
     : 0;
 
 #else
   /*
    * Fallback solution.
    */
   int status;
-  
+
 # if defined(TRIO_PLATFORM_UNIX)
   void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
 # endif
-  
+
   double infinity = trio_pinf();
-  
+
   status = ((number == infinity)
             ? 1
             : ((number == -infinity) ? -1 : 0));
-  
+
 # if defined(TRIO_PLATFORM_UNIX)
   signal(SIGFPE, signal_handler);
 # endif
-  
+
   return status;
-  
+
 #endif
 }
 
 #if 0
         /* Temporary fix - this routine is not used anywhere */
 /**
    Check for finity.
 
    @param number An arbitrary floating-point number.
    @return Boolean value indicating whether or not the number is a finite.
 */
 TRIO_PUBLIC int
 trio_isfinite
 TRIO_ARGS1((number),
            double number)
 {
 #if defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isfinite)
   /*
    * C99 defines isfinite() as a macro.
    */
   return isfinite(number);
-  
+
 #elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
   /*
    * Microsoft Visual C++ and Borland C++ Builder use _finite().
    */
   return _finite(number);
 
 #elif defined(USE_IEEE_754)
   /*
    * Examine IEEE 754 bit-pattern. For finity we do not care about the
    * mantissa.
    */
   int dummy;
 
   return (! trio_is_special_quantity(number, &dummy));
 
 #else
   /*
    * Fallback solution.
    */
   return ((trio_isinf(number) == 0) && (trio_isnan(number) == 0));
-  
+
 #endif
 }
 
 #endif
 
 /*
  * The sign of NaN is always false
  */
 TRIO_PUBLIC int
 trio_fpclassify_and_signbit
@@ skipping 28 matching lines @@
 #  define TRIO_QUIET_NAN FP_QNAN
 #  define TRIO_SIGNALLING_NAN FP_SNAN
 #  define TRIO_POSITIVE_INFINITY FP_POS_INF
 #  define TRIO_NEGATIVE_INFINITY FP_NEG_INF
 #  define TRIO_POSITIVE_SUBNORMAL FP_POS_DENORM
 #  define TRIO_NEGATIVE_SUBNORMAL FP_NEG_DENORM
 #  define TRIO_POSITIVE_ZERO FP_POS_ZERO
 #  define TRIO_NEGATIVE_ZERO FP_NEG_ZERO
 #  define TRIO_POSITIVE_NORMAL FP_POS_NORM
 #  define TRIO_NEGATIVE_NORMAL FP_NEG_NORM
-  
+
 # elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
   /*
    * Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
    * function.
    */
 #  define TRIO_FPCLASSIFY(n) _fpclass(n)
 #  define TRIO_QUIET_NAN _FPCLASS_QNAN
 #  define TRIO_SIGNALLING_NAN _FPCLASS_SNAN
 #  define TRIO_POSITIVE_INFINITY _FPCLASS_PINF
 #  define TRIO_NEGATIVE_INFINITY _FPCLASS_NINF
 #  define TRIO_POSITIVE_SUBNORMAL _FPCLASS_PD
 #  define TRIO_NEGATIVE_SUBNORMAL _FPCLASS_ND
 #  define TRIO_POSITIVE_ZERO _FPCLASS_PZ
 #  define TRIO_NEGATIVE_ZERO _FPCLASS_NZ
 #  define TRIO_POSITIVE_NORMAL _FPCLASS_PN
 #  define TRIO_NEGATIVE_NORMAL _FPCLASS_NN
-  
+
 # elif defined(FP_PLUS_NORM)
   /*
    * HP-UX 9.x and 10.x have an fpclassify() function, that is different
    * from the C99 fpclassify() macro supported on HP-UX 11.x.
    *
    * AIX has class() for C, and _class() for C++, which returns the
    * same values as the HP-UX fpclassify() function.
    */
 #  if defined(TRIO_PLATFORM_AIX)
 #   if defined(__cplusplus)
@@ skipping 44 matching lines @@
     *is_negative = TRIO_FALSE;
     return TRIO_FP_NORMAL;
   case TRIO_NEGATIVE_NORMAL:
     *is_negative = TRIO_TRUE;
     return TRIO_FP_NORMAL;
   default:
     /* Just in case... */
     *is_negative = (number < 0.0);
     return TRIO_FP_NORMAL;
   }
-  
+
 # else
   /*
    * Fallback solution.
    */
   int rc;
-  
+
   if (number == 0.0) {
     /*
      * In IEEE 754 the sign of zero is ignored in comparisons, so we
      * have to handle this as a special case by examining the sign bit
      * directly.
      */
 #  if defined(USE_IEEE_754)
     *is_negative = trio_is_negative(number);
 #  else
     *is_negative = TRIO_FALSE; /* FIXME */
@@ skipping 11 matching lines @@
   if ((number > 0.0) && (number < DBL_MIN)) {
     *is_negative = TRIO_FALSE;
     return TRIO_FP_SUBNORMAL;
   }
   if ((number < 0.0) && (number > -DBL_MIN)) {
     *is_negative = TRIO_TRUE;
     return TRIO_FP_SUBNORMAL;
   }
   *is_negative = (number < 0.0);
   return TRIO_FP_NORMAL;
-  
+
 # endif
 #endif
 }
 
 /**
    Examine the sign of a number.
 
    @param number An arbitrary floating-point number.
    @return Boolean value indicating whether or not the number has the
    sign bit set (i.e. is negative).
 */
 TRIO_PUBLIC int
 trio_signbit
 TRIO_ARGS1((number),
            double number)
 {
   int is_negative;
-  
+
   (void)trio_fpclassify_and_signbit(number, &is_negative);
   return is_negative;
 }
 
 #if 0
         /* Temporary fix - this routine is not used in libxml */
 /**
    Examine the class of a number.
 
    @param number An arbitrary floating-point number.
    @return Enumerable value indicating the class of @p number
 */
 TRIO_PUBLIC int
 trio_fpclassify
 TRIO_ARGS1((number),
            double number)
 {
   int dummy;
-  
+
   return trio_fpclassify_and_signbit(number, &dummy);
 }
 
 #endif
 
 /** @} SpecialQuantities */
 
 /*************************************************************************
  * For test purposes.
  *
@@ skipping 54 matching lines @@
 
   print_class("Nan", my_nan);
   print_class("PInf", my_pinf);
   print_class("NInf", my_ninf);
   print_class("PZero", 0.0);
   print_class("NZero", -0.0);
   print_class("PNorm", 1.0);
   print_class("NNorm", -1.0);
   print_class("PSub", 1.01e-307 - 1.00e-307);
   print_class("NSub", 1.00e-307 - 1.01e-307);
-  
+
   printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
          my_nan,
          ((unsigned char *)&my_nan)[0],
          ((unsigned char *)&my_nan)[1],
          ((unsigned char *)&my_nan)[2],
          ((unsigned char *)&my_nan)[3],
          ((unsigned char *)&my_nan)[4],
          ((unsigned char *)&my_nan)[5],
          ((unsigned char *)&my_nan)[6],
          ((unsigned char *)&my_nan)[7],
@@ skipping 13 matching lines @@
          my_ninf,
          ((unsigned char *)&my_ninf)[0],
          ((unsigned char *)&my_ninf)[1],
          ((unsigned char *)&my_ninf)[2],
          ((unsigned char *)&my_ninf)[3],
          ((unsigned char *)&my_ninf)[4],
          ((unsigned char *)&my_ninf)[5],
          ((unsigned char *)&my_ninf)[6],
          ((unsigned char *)&my_ninf)[7],
          trio_isnan(my_ninf), trio_isinf(my_ninf));
-  
+
 # if defined(TRIO_PLATFORM_UNIX)
   signal_handler = signal(SIGFPE, SIG_IGN);
 # endif
-  
+
   my_pinf = DBL_MAX + DBL_MAX;
   my_ninf = -my_pinf;
   my_nan = my_pinf / my_pinf;
 
 # if defined(TRIO_PLATFORM_UNIX)
   signal(SIGFPE, signal_handler);
 # endif
-  
+
   printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
          my_nan,
          ((unsigned char *)&my_nan)[0],
          ((unsigned char *)&my_nan)[1],
          ((unsigned char *)&my_nan)[2],
          ((unsigned char *)&my_nan)[3],
          ((unsigned char *)&my_nan)[4],
          ((unsigned char *)&my_nan)[5],
          ((unsigned char *)&my_nan)[6],
          ((unsigned char *)&my_nan)[7],
@@ skipping 13 matching lines @@
          my_ninf,
          ((unsigned char *)&my_ninf)[0],
          ((unsigned char *)&my_ninf)[1],
          ((unsigned char *)&my_ninf)[2],
          ((unsigned char *)&my_ninf)[3],
          ((unsigned char *)&my_ninf)[4],
          ((unsigned char *)&my_ninf)[5],
          ((unsigned char *)&my_ninf)[6],
          ((unsigned char *)&my_ninf)[7],
          trio_isnan(my_ninf), trio_isinf(my_ninf));
-  
+
   return 0;
 }
 #endif