lib/strtod.c

   1 /* Copyright (C) 1991-1992, 1997, 1999, 2003, 2006, 2008-2020 Free Software
   2    Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #if ! defined USE_LONG_DOUBLE
  18 # include <config.h>
  19 #endif
  20
  21 /* Specification.  */
  22 #include <stdlib.h>
  23
  24 #include <ctype.h>      /* isspace() */
  25 #include <errno.h>
  26 #include <float.h>      /* {DBL,LDBL}_{MIN,MAX} */
  27 #include <limits.h>     /* LONG_{MIN,MAX} */
  28 #include <locale.h>     /* localeconv() */
  29 #include <math.h>       /* NAN */
  30 #include <stdbool.h>
  31 #include <stdio.h>      /* sprintf() */
  32 #include <string.h>     /* strdup() */
  33 #if HAVE_NL_LANGINFO
  34 # include <langinfo.h>
  35 #endif
  36
  37 #include "c-ctype.h"
  38
  39 #undef MIN
  40 #undef MAX
  41 #ifdef USE_LONG_DOUBLE
  42 # define STRTOD strtold
  43 # define LDEXP ldexpl
  44 # if defined __hpux && defined __hppa
  45    /* We cannot call strtold on HP-UX/hppa, because its return type is a struct,
  46       not a 'long double'.  */
  47 #  define HAVE_UNDERLYING_STRTOD 0
  48 # elif STRTOLD_HAS_UNDERFLOW_BUG
  49    /* strtold would not set errno=ERANGE upon underflow.  */
  50 #  define HAVE_UNDERLYING_STRTOD 0
  51 # else
  52 #  define HAVE_UNDERLYING_STRTOD HAVE_STRTOLD
  53 # endif
  54 # define DOUBLE long double
  55 # define MIN LDBL_MIN
  56 # define MAX LDBL_MAX
  57 # define L_(literal) literal##L
  58 #else
  59 # define STRTOD strtod
  60 # define LDEXP ldexp
  61 # define HAVE_UNDERLYING_STRTOD 1
  62 # define DOUBLE double
  63 # define MIN DBL_MIN
  64 # define MAX DBL_MAX
  65 # define L_(literal) literal
  66 #endif
  67
  68 #if (defined USE_LONG_DOUBLE ? HAVE_LDEXPM_IN_LIBC : HAVE_LDEXP_IN_LIBC)
  69 # define USE_LDEXP 1
  70 #else
  71 # define USE_LDEXP 0
  72 #endif
  73
  74 /* Return true if C is a space in the current locale, avoiding
  75    problems with signed char and isspace.  */
  76 static bool
  77 locale_isspace (char c)
  78 {
  79   unsigned char uc = c;
  80   return isspace (uc) != 0;
  81 }
  82
  83 /* Determine the decimal-point character according to the current locale.  */
  84 static char
  85 decimal_point_char (void)
  86 {
  87   const char *point;
  88   /* Determine it in a multithread-safe way.  We know nl_langinfo is
  89      multithread-safe on glibc systems and Mac OS X systems, but is not required
  90      to be multithread-safe by POSIX.  sprintf(), however, is multithread-safe.
  91      localeconv() is rarely multithread-safe.  */
  92 #if HAVE_NL_LANGINFO && (__GLIBC__ || defined __UCLIBC__ || (defined __APPLE__ && defined __MACH__))
  93   point = nl_langinfo (RADIXCHAR);
  94 #elif 1
  95   char pointbuf[5];
  96   sprintf (pointbuf, "%#.0f", 1.0);
  97   point = &pointbuf[1];
  98 #else
  99   point = localeconv () -> decimal_point;
 100 #endif
 101   /* The decimal point is always a single byte: either '.' or ','.  */
 102   return (point[0] != '\0' ? point[0] : '.');
 103 }
 104
 105 #if !USE_LDEXP
 106  #undef LDEXP
 107  #define LDEXP dummy_ldexp
 108  /* A dummy definition that will never be invoked.  */
 109  static DOUBLE LDEXP (DOUBLE x _GL_UNUSED, int exponent _GL_UNUSED)
 110  {
 111    abort ();
 112    return L_(0.0);
 113  }
 114 #endif
 115
 116 /* Return X * BASE**EXPONENT.  Return an extreme value and set errno
 117    to ERANGE if underflow or overflow occurs.  */
 118 static DOUBLE
 119 scale_radix_exp (DOUBLE x, int radix, long int exponent)
 120 {
 121   /* If RADIX == 10, this code is neither precise nor fast; it is
 122      merely a straightforward and relatively portable approximation.
 123      If N == 2, this code is precise on a radix-2 implementation,
 124      albeit perhaps not fast if ldexp is not in libc.  */
 125
 126   long int e = exponent;
 127
 128   if (USE_LDEXP && radix == 2)
 129     return LDEXP (x, e < INT_MIN ? INT_MIN : INT_MAX < e ? INT_MAX : e);
 130   else
 131     {
 132       DOUBLE r = x;
 133
 134       if (r != 0)
 135         {
 136           if (e < 0)
 137             {
 138               while (e++ != 0)
 139                 {
 140                   r /= radix;
 141                   if (r == 0 && x != 0)
 142                     {
 143                       errno = ERANGE;
 144                       break;
 145                     }
 146                 }
 147             }
 148           else
 149             {
 150               while (e-- != 0)
 151                 {
 152                   if (r < -MAX / radix)
 153                     {
 154                       errno = ERANGE;
 155                       return -HUGE_VAL;
 156                     }
 157                   else if (MAX / radix < r)
 158                     {
 159                       errno = ERANGE;
 160                       return HUGE_VAL;
 161                     }
 162                   else
 163                     r *= radix;
 164                 }
 165             }
 166         }
 167
 168       return r;
 169     }
 170 }
 171
 172 /* Parse a number at NPTR; this is a bit like strtol (NPTR, ENDPTR)
 173    except there are no leading spaces or signs or "0x", and ENDPTR is
 174    nonnull.  The number uses a base BASE (either 10 or 16) fraction, a
 175    radix RADIX (either 10 or 2) exponent, and exponent character
 176    EXPCHAR.  BASE is RADIX**RADIX_MULTIPLIER.  */
 177 static DOUBLE
 178 parse_number (const char *nptr,
 179               int base, int radix, int radix_multiplier, char radixchar,
 180               char expchar,
 181               char **endptr)
 182 {
 183   const char *s = nptr;
 184   const char *digits_start;
 185   const char *digits_end;
 186   const char *radixchar_ptr;
 187   long int exponent;
 188   DOUBLE num;
 189
 190   /* First, determine the start and end of the digit sequence.  */
 191   digits_start = s;
 192   radixchar_ptr = NULL;
 193   for (;; ++s)
 194     {
 195       if (base == 16 ? c_isxdigit (*s) : c_isdigit (*s))
 196         ;
 197       else if (radixchar_ptr == NULL && *s == radixchar)
 198         {
 199           /* Record that we have found the decimal point.  */
 200           radixchar_ptr = s;
 201         }
 202       else
 203         /* Any other character terminates the digit sequence.  */
 204         break;
 205     }
 206   digits_end = s;
 207   /* Now radixchar_ptr == NULL or
 208      digits_start <= radixchar_ptr < digits_end.  */
 209
 210   if (false)
 211     { /* Unoptimized.  */
 212       exponent =
 213         (radixchar_ptr != NULL
 214          ? - (long int) (digits_end - radixchar_ptr - 1)
 215          : 0);
 216     }
 217   else
 218     { /* Remove trailing zero digits.  This reduces rounding errors for
 219          inputs such as 1.0000000000 or 10000000000e-10.  */
 220       while (digits_end > digits_start)
 221         {
 222           if (digits_end - 1 == radixchar_ptr || *(digits_end - 1) == '0')
 223             digits_end--;
 224           else
 225             break;
 226         }
 227       exponent =
 228         (radixchar_ptr != NULL
 229          ? (digits_end > radixchar_ptr
 230             ? - (long int) (digits_end - radixchar_ptr - 1)
 231             : (long int) (radixchar_ptr - digits_end))
 232          : (long int) (s - digits_end));
 233     }
 234
 235   /* Then, convert the digit sequence to a number.  */
 236   {
 237     const char *dp;
 238     num = 0;
 239     for (dp = digits_start; dp < digits_end; dp++)
 240       if (dp != radixchar_ptr)
 241         {
 242           int digit;
 243
 244           /* Make sure that multiplication by BASE will not overflow.  */
 245           if (!(num <= MAX / base))
 246             {
 247               /* The value of the digit and all subsequent digits don't matter,
 248                  since we have already gotten as many digits as can be
 249                  represented in a 'DOUBLE'.  This doesn't necessarily mean that
 250                  the result will overflow: The exponent may reduce it to within
 251                  range.  */
 252               exponent +=
 253                 (digits_end - dp)
 254                 - (radixchar_ptr >= dp && radixchar_ptr < digits_end ? 1 : 0);
 255               break;
 256             }
 257
 258           /* Eat the next digit.  */
 259           if (c_isdigit (*dp))
 260             digit = *dp - '0';
 261           else if (base == 16 && c_isxdigit (*dp))
 262             digit = c_tolower (*dp) - ('a' - 10);
 263           else
 264             abort ();
 265           num = num * base + digit;
 266         }
 267   }
 268
 269   exponent = exponent * radix_multiplier;
 270
 271   /* Finally, parse the exponent.  */
 272   if (c_tolower (*s) == expchar && ! locale_isspace (s[1]))
 273     {
 274       /* Add any given exponent to the implicit one.  */
 275       int saved_errno = errno;
 276       char *end;
 277       long int value = strtol (s + 1, &end, 10);
 278       errno = saved_errno;
 279
 280       if (s + 1 != end)
 281         {
 282           /* Skip past the exponent, and add in the implicit exponent,
 283              resulting in an extreme value on overflow.  */
 284           s = end;
 285           exponent =
 286             (exponent < 0
 287              ? (value < LONG_MIN - exponent ? LONG_MIN : exponent + value)
 288              : (LONG_MAX - exponent < value ? LONG_MAX : exponent + value));
 289         }
 290     }
 291
 292   *endptr = (char *) s;
 293   return scale_radix_exp (num, radix, exponent);
 294 }
 295
 296 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
 297    ICC 10.0 has a bug when optimizing the expression -zero.
 298    The expression -MIN * MIN does not work when cross-compiling
 299    to PowerPC on Mac OS X 10.5.  */
 300 static DOUBLE
 301 minus_zero (void)
 302 {
 303 #if defined __hpux || defined __sgi || defined __ICC
 304   return -MIN * MIN;
 305 #else
 306   return -0.0;
 307 #endif
 308 }
 309
 310 /* Convert NPTR to a DOUBLE.  If ENDPTR is not NULL, a pointer to the
 311    character after the last one used in the number is put in *ENDPTR.  */
 312 DOUBLE
 313 STRTOD (const char *nptr, char **endptr)
 314 #if HAVE_UNDERLYING_STRTOD
 315 # ifdef USE_LONG_DOUBLE
 316 #  undef strtold
 317 # else
 318 #  undef strtod
 319 # endif
 320 #else
 321 # undef STRTOD
 322 # define STRTOD(NPTR,ENDPTR) \
 323    parse_number (NPTR, 10, 10, 1, radixchar, 'e', ENDPTR)
 324 #endif
 325 /* From here on, STRTOD refers to the underlying implementation.  It needs
 326    to handle only finite unsigned decimal numbers with non-null ENDPTR.  */
 327 {
 328   char radixchar;
 329   bool negative = false;
 330
 331   /* The number so far.  */
 332   DOUBLE num;
 333
 334   const char *s = nptr;
 335   const char *end;
 336   char *endbuf;
 337   int saved_errno = errno;
 338
 339   radixchar = decimal_point_char ();
 340
 341   /* Eat whitespace.  */
 342   while (locale_isspace (*s))
 343     ++s;
 344
 345   /* Get the sign.  */
 346   negative = *s == '-';
 347   if (*s == '-' || *s == '+')
 348     ++s;
 349
 350   num = STRTOD (s, &endbuf);
 351   end = endbuf;
 352
 353   if (c_isdigit (s[*s == radixchar]))
 354     {
 355       /* If a hex float was converted incorrectly, do it ourselves.
 356          If the string starts with "0x" but does not contain digits,
 357          consume the "0" ourselves.  If a hex float is followed by a
 358          'p' but no exponent, then adjust the end pointer.  */
 359       if (*s == '0' && c_tolower (s[1]) == 'x')
 360         {
 361           if (! c_isxdigit (s[2 + (s[2] == radixchar)]))
 362             {
 363               end = s + 1;
 364
 365               /* strtod() on z/OS returns ERANGE for "0x".  */
 366               errno = saved_errno;
 367             }
 368           else if (end <= s + 2)
 369             {
 370               num = parse_number (s + 2, 16, 2, 4, radixchar, 'p', &endbuf);
 371               end = endbuf;
 372             }
 373           else
 374             {
 375               const char *p = s + 2;
 376               while (p < end && c_tolower (*p) != 'p')
 377                 p++;
 378               if (p < end && ! c_isdigit (p[1 + (p[1] == '-' || p[1] == '+')]))
 379                 {
 380                   char *dup = strdup (s);
 381                   errno = saved_errno;
 382                   if (!dup)
 383                     {
 384                       /* Not really our day, is it.  Rounding errors are
 385                          better than outright failure.  */
 386                       num =
 387                         parse_number (s + 2, 16, 2, 4, radixchar, 'p', &endbuf);
 388                     }
 389                   else
 390                     {
 391                       dup[p - s] = '\0';
 392                       num = STRTOD (dup, &endbuf);
 393                       saved_errno = errno;
 394                       free (dup);
 395                       errno = saved_errno;
 396                     }
 397                   end = p;
 398                 }
 399             }
 400         }
 401       else
 402         {
 403           /* If "1e 1" was misparsed as 10.0 instead of 1.0, re-do the
 404              underlying STRTOD on a copy of the original string
 405              truncated to avoid the bug.  */
 406           const char *e = s + 1;
 407           while (e < end && c_tolower (*e) != 'e')
 408             e++;
 409           if (e < end && ! c_isdigit (e[1 + (e[1] == '-' || e[1] == '+')]))
 410             {
 411               char *dup = strdup (s);
 412               errno = saved_errno;
 413               if (!dup)
 414                 {
 415                   /* Not really our day, is it.  Rounding errors are
 416                      better than outright failure.  */
 417                   num = parse_number (s, 10, 10, 1, radixchar, 'e', &endbuf);
 418                 }
 419               else
 420                 {
 421                   dup[e - s] = '\0';
 422                   num = STRTOD (dup, &endbuf);
 423                   saved_errno = errno;
 424                   free (dup);
 425                   errno = saved_errno;
 426                 }
 427               end = e;
 428             }
 429         }
 430
 431       s = end;
 432     }
 433
 434   /* Check for infinities and NaNs.  */
 435   else if (c_tolower (*s) == 'i'
 436            && c_tolower (s[1]) == 'n'
 437            && c_tolower (s[2]) == 'f')
 438     {
 439       s += 3;
 440       if (c_tolower (*s) == 'i'
 441           && c_tolower (s[1]) == 'n'
 442           && c_tolower (s[2]) == 'i'
 443           && c_tolower (s[3]) == 't'
 444           && c_tolower (s[4]) == 'y')
 445         s += 5;
 446       num = HUGE_VAL;
 447       errno = saved_errno;
 448     }
 449   else if (c_tolower (*s) == 'n'
 450            && c_tolower (s[1]) == 'a'
 451            && c_tolower (s[2]) == 'n')
 452     {
 453       s += 3;
 454       if (*s == '(')
 455         {
 456           const char *p = s + 1;
 457           while (c_isalnum (*p))
 458             p++;
 459           if (*p == ')')
 460             s = p + 1;
 461         }
 462
 463       /* If the underlying implementation misparsed the NaN, assume
 464          its result is incorrect, and return a NaN.  Normally it's
 465          better to use the underlying implementation's result, since a
 466          nice implementation populates the bits of the NaN according
 467          to interpreting n-char-sequence as a hexadecimal number.  */
 468       if (s != end || num == num)
 469         num = NAN;
 470       errno = saved_errno;
 471     }
 472   else
 473     {
 474       /* No conversion could be performed.  */
 475       errno = EINVAL;
 476       s = nptr;
 477     }
 478
 479   if (endptr != NULL)
 480     *endptr = (char *) s;
 481   /* Special case -0.0, since at least ICC miscompiles negation.  We
 482      can't use copysign(), as that drags in -lm on some platforms.  */
 483   if (!num && negative)
 484     return minus_zero ();
 485   return negative ? -num : num;
 486 }