Move real code tp strtod_l.c and add wrapper.
authordrepper <drepper>
Sun, 14 Mar 2004 20:48:09 +0000 (20:48 +0000)
committerdrepper <drepper>
Sun, 14 Mar 2004 20:48:09 +0000 (20:48 +0000)
stdlib/strtod.c

index 63d7a4d..1d4e4a4 100644 (file)
@@ -1,6 +1,6 @@
 /* Read decimal floating point numbers.
    This file is part of the GNU C Library.
-   Copyright (C) 1995-2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1995-2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
 
    The GNU C Library is free software; you can redistribute it and/or
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-/* Configuration part.  These macros are defined by `strtold.c',
-   `strtof.c', `wcstod.c', `wcstold.c', and `wcstof.c' to produce the
-   `long double' and `float' versions of the reader.  */
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale/localeinfo.h>
+
+
 #ifndef FLOAT
-# define FLOAT         double
-# define FLT           DBL
+# define FLOAT double
 # ifdef USE_WIDE_CHAR
-#  ifdef USE_IN_EXTENDED_LOCALE_MODEL
-#   define STRTOF      __wcstod_l
-#  else
-#   define STRTOF      wcstod
-#  endif
+#  define STRTOF wcstod
+#  define STRTOF_L __wcstod_l
 # else
-#  ifdef USE_IN_EXTENDED_LOCALE_MODEL
-#   define STRTOF      __strtod_l
-#  else
-#   define STRTOF      strtod
-#  endif
+#  define STRTOF strtod
+#  define STRTOF_L __strtod_l
 # endif
-# define MPN2FLOAT     __mpn_construct_double
-# define FLOAT_HUGE_VAL        HUGE_VAL
-# define SET_MANTISSA(flt, mant) \
-  do { union ieee754_double u;                                               \
-       u.d = (flt);                                                          \
-       if ((mant & 0xfffffffffffffULL) == 0)                                 \
-        mant = 0x8000000000000ULL;                                           \
-       u.ieee.mantissa0 = ((mant) >> 32) & 0xfffff;                          \
-       u.ieee.mantissa1 = (mant) & 0xffffffff;                               \
-       (flt) = u.d;                                                          \
-  } while (0)
-#endif
-/* End of configuration part.  */
-\f
-#include <ctype.h>
-#include <errno.h>
-#include <float.h>
-#include <ieee754.h>
-#include "../locale/localeinfo.h"
-#include <locale.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* The gmp headers need some configuration frobs.  */
-#define HAVE_ALLOCA 1
-
-/* Include gmp-mparam.h first, such that definitions of _SHORT_LIMB
-   and _LONG_LONG_LIMB in it can take effect into gmp.h.  */
-#include <gmp-mparam.h>
-#include <gmp.h>
-#include <gmp-impl.h>
-#include <longlong.h>
-#include "fpioconst.h"
-
-#define NDEBUG 1
-#include <assert.h>
-
-
-/* We use this code also for the extended locale handling where the
-   function gets as an additional argument the locale which has to be
-   used.  To access the values we have to redefine the _NL_CURRENT
-   macro.  */
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-# undef _NL_CURRENT
-# define _NL_CURRENT(category, item) \
-  (current->values[_NL_ITEM_INDEX (item)].string)
-# define LOCALE_PARAM , loc
-# define LOCALE_PARAM_DECL __locale_t loc;
-#else
-# define LOCALE_PARAM
-# define LOCALE_PARAM_DECL
-#endif
-
-#if defined _LIBC || defined HAVE_WCHAR_H
-# include <wchar.h>
 #endif
 
 #ifdef USE_WIDE_CHAR
 # include <wctype.h>
 # define STRING_TYPE wchar_t
-# define CHAR_TYPE wint_t
-# define L_(Ch) L##Ch
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-#  define ISSPACE(Ch) __iswspace_l ((Ch), loc)
-#  define ISDIGIT(Ch) __iswdigit_l ((Ch), loc)
-#  define ISXDIGIT(Ch) __iswxdigit_l ((Ch), loc)
-#  define TOLOWER(Ch) __towlower_l ((Ch), loc)
-#  define STRNCASECMP(S1, S2, N) __wcsncasecmp_l ((S1), (S2), (N), loc)
-#  define STRTOULL(S, E, B) ____wcstoull_l_internal ((S), (E), (B), 0, loc)
-# else
-#  define ISSPACE(Ch) iswspace (Ch)
-#  define ISDIGIT(Ch) iswdigit (Ch)
-#  define ISXDIGIT(Ch) iswxdigit (Ch)
-#  define TOLOWER(Ch) towlower (Ch)
-#  define STRNCASECMP(S1, S2, N) __wcsncasecmp ((S1), (S2), (N))
-#  define STRTOULL(S, E, B) __wcstoull_internal ((S), (E), (B), 0)
-# endif
 #else
 # define STRING_TYPE char
-# define CHAR_TYPE char
-# define L_(Ch) Ch
-# ifdef USE_IN_EXTENDED_LOCALE_MODEL
-#  define ISSPACE(Ch) __isspace_l ((Ch), loc)
-#  define ISDIGIT(Ch) __isdigit_l ((Ch), loc)
-#  define ISXDIGIT(Ch) __isxdigit_l ((Ch), loc)
-#  define TOLOWER(Ch) __tolower_l ((Ch), loc)
-#  define STRNCASECMP(S1, S2, N) __strncasecmp_l ((S1), (S2), (N), loc)
-#  define STRTOULL(S, E, B) ____strtoull_l_internal ((S), (E), (B), 0, loc)
-# else
-#  define ISSPACE(Ch) isspace (Ch)
-#  define ISDIGIT(Ch) isdigit (Ch)
-#  define ISXDIGIT(Ch) isxdigit (Ch)
-#  define TOLOWER(Ch) tolower (Ch)
-#  define STRNCASECMP(S1, S2, N) __strncasecmp ((S1), (S2), (N))
-#  define STRTOULL(S, E, B) __strtoull_internal ((S), (E), 0, (B))
-# endif
-#endif
-
-
-/* Constants we need from float.h; select the set for the FLOAT precision.  */
-#define MANT_DIG       PASTE(FLT,_MANT_DIG)
-#define        DIG             PASTE(FLT,_DIG)
-#define        MAX_EXP         PASTE(FLT,_MAX_EXP)
-#define        MIN_EXP         PASTE(FLT,_MIN_EXP)
-#define MAX_10_EXP     PASTE(FLT,_MAX_10_EXP)
-#define MIN_10_EXP     PASTE(FLT,_MIN_10_EXP)
-
-/* Extra macros required to get FLT expanded before the pasting.  */
-#define PASTE(a,b)     PASTE1(a,b)
-#define PASTE1(a,b)    a##b
-
-/* Function to construct a floating point number from an MP integer
-   containing the fraction bits, a base 2 exponent, and a sign flag.  */
-extern FLOAT MPN2FLOAT (mp_srcptr mpn, int exponent, int negative);
-\f
-/* Definitions according to limb size used.  */
-#if    BITS_PER_MP_LIMB == 32
-#  define MAX_DIG_PER_LIMB     9
-#  define MAX_FAC_PER_LIMB     1000000000UL
-#elif  BITS_PER_MP_LIMB == 64
-#  define MAX_DIG_PER_LIMB     19
-#  define MAX_FAC_PER_LIMB     10000000000000000000ULL
-#else
-#  error "mp_limb_t size " BITS_PER_MP_LIMB "not accounted for"
 #endif
 
-
-/* Local data structure.  */
-static const mp_limb_t _tens_in_limb[MAX_DIG_PER_LIMB + 1] =
-{    0,                   10,                   100,
-     1000,                10000,                100000L,
-     1000000L,            10000000L,            100000000L,
-     1000000000L
-#if BITS_PER_MP_LIMB > 32
-               ,         10000000000ULL,       100000000000ULL,
-     1000000000000ULL,    10000000000000ULL,    100000000000000ULL,
-     1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
-     1000000000000000000ULL, 10000000000000000000ULL
-#endif
-#if BITS_PER_MP_LIMB > 64
-  #error "Need to expand tens_in_limb table to" MAX_DIG_PER_LIMB
-#endif
-};
-\f
-#ifndef        howmany
-#define        howmany(x,y)            (((x)+((y)-1))/(y))
-#endif
-#define SWAP(x, y)             ({ typeof(x) _tmp = x; x = y; y = _tmp; })
-
-#define NDIG                   (MAX_10_EXP - MIN_10_EXP + 2 * MANT_DIG)
-#define HEXNDIG                        ((MAX_EXP - MIN_EXP + 7) / 8 + 2 * MANT_DIG)
-#define        RETURN_LIMB_SIZE                howmany (MANT_DIG, BITS_PER_MP_LIMB)
-
-#define RETURN(val,end)                                                              \
-    do { if (endptr != NULL) *endptr = (STRING_TYPE *) (end);                \
-        return val; } while (0)
-
-/* Maximum size necessary for mpn integers to hold floating point numbers.  */
-#define        MPNSIZE         (howmany (MAX_EXP + 2 * MANT_DIG, BITS_PER_MP_LIMB) \
-                        + 2)
-/* Declare an mpn integer variable that big.  */
-#define        MPN_VAR(name)   mp_limb_t name[MPNSIZE]; mp_size_t name##size
-/* Copy an mpn integer value.  */
-#define MPN_ASSIGN(dst, src) \
-       memcpy (dst, src, (dst##size = src##size) * sizeof (mp_limb_t))
-
-
-/* Return a floating point number of the needed type according to the given
-   multi-precision number after possible rounding.  */
-static FLOAT
-round_and_return (mp_limb_t *retval, int exponent, int negative,
-                 mp_limb_t round_limb, mp_size_t round_bit, int more_bits)
-{
-  if (exponent < MIN_EXP - 1)
-    {
-      mp_size_t shift = MIN_EXP - 1 - exponent;
-
-      if (shift > MANT_DIG)
-       {
-         __set_errno (EDOM);
-         return 0.0;
-       }
-
-      more_bits |= (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0;
-      if (shift == MANT_DIG)
-       /* This is a special case to handle the very seldom case where
-          the mantissa will be empty after the shift.  */
-       {
-         int i;
-
-         round_limb = retval[RETURN_LIMB_SIZE - 1];
-         round_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
-         for (i = 0; i < RETURN_LIMB_SIZE; ++i)
-           more_bits |= retval[i] != 0;
-         MPN_ZERO (retval, RETURN_LIMB_SIZE);
-       }
-      else if (shift >= BITS_PER_MP_LIMB)
-       {
-         int i;
-
-         round_limb = retval[(shift - 1) / BITS_PER_MP_LIMB];
-         round_bit = (shift - 1) % BITS_PER_MP_LIMB;
-         for (i = 0; i < (shift - 1) / BITS_PER_MP_LIMB; ++i)
-           more_bits |= retval[i] != 0;
-         more_bits |= ((round_limb & ((((mp_limb_t) 1) << round_bit) - 1))
-                       != 0);
-
-         (void) __mpn_rshift (retval, &retval[shift / BITS_PER_MP_LIMB],
-                               RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB),
-                               shift % BITS_PER_MP_LIMB);
-          MPN_ZERO (&retval[RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB)],
-                    shift / BITS_PER_MP_LIMB);
-       }
-      else if (shift > 0)
-       {
-          round_limb = retval[0];
-          round_bit = shift - 1;
-         (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, shift);
-       }
-      /* This is a hook for the m68k long double format, where the
-        exponent bias is the same for normalized and denormalized
-        numbers.  */
-#ifndef DENORM_EXP
-# define DENORM_EXP (MIN_EXP - 2)
-#endif
-      exponent = DENORM_EXP;
-    }
-
-  if ((round_limb & (((mp_limb_t) 1) << round_bit)) != 0
-      && (more_bits || (retval[0] & 1) != 0
-          || (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0))
-    {
-      mp_limb_t cy = __mpn_add_1 (retval, retval, RETURN_LIMB_SIZE, 1);
-
-      if (((MANT_DIG % BITS_PER_MP_LIMB) == 0 && cy) ||
-          ((MANT_DIG % BITS_PER_MP_LIMB) != 0 &&
-           (retval[RETURN_LIMB_SIZE - 1]
-            & (((mp_limb_t) 1) << (MANT_DIG % BITS_PER_MP_LIMB))) != 0))
-       {
-         ++exponent;
-         (void) __mpn_rshift (retval, retval, RETURN_LIMB_SIZE, 1);
-         retval[RETURN_LIMB_SIZE - 1]
-           |= ((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB);
-       }
-      else if (exponent == DENORM_EXP
-              && (retval[RETURN_LIMB_SIZE - 1]
-                  & (((mp_limb_t) 1) << ((MANT_DIG - 1) % BITS_PER_MP_LIMB)))
-              != 0)
-         /* The number was denormalized but now normalized.  */
-       exponent = MIN_EXP - 1;
-    }
-
-  if (exponent > MAX_EXP)
-    return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
-
-  return MPN2FLOAT (retval, exponent, negative);
-}
-
-
-/* Read a multi-precision integer starting at STR with exactly DIGCNT digits
-   into N.  Return the size of the number limbs in NSIZE at the first
-   character od the string that is not part of the integer as the function
-   value.  If the EXPONENT is small enough to be taken as an additional
-   factor for the resulting number (see code) multiply by it.  */
-static const STRING_TYPE *
-str_to_mpn (const STRING_TYPE *str, int digcnt, mp_limb_t *n, mp_size_t *nsize,
-           int *exponent
-#ifndef USE_WIDE_CHAR
-           , const char *decimal, size_t decimal_len, const char *thousands
-#endif
-
-           )
-{
-  /* Number of digits for actual limb.  */
-  int cnt = 0;
-  mp_limb_t low = 0;
-  mp_limb_t start;
-
-  *nsize = 0;
-  assert (digcnt > 0);
-  do
-    {
-      if (cnt == MAX_DIG_PER_LIMB)
-       {
-         if (*nsize == 0)
-           {
-             n[0] = low;
-             *nsize = 1;
-           }
-         else
-           {
-             mp_limb_t cy;
-             cy = __mpn_mul_1 (n, n, *nsize, MAX_FAC_PER_LIMB);
-             cy += __mpn_add_1 (n, n, *nsize, low);
-             if (cy != 0)
-               {
-                 n[*nsize] = cy;
-                 ++(*nsize);
-               }
-           }
-         cnt = 0;
-         low = 0;
-       }
-
-      /* There might be thousands separators or radix characters in
-        the string.  But these all can be ignored because we know the
-        format of the number is correct and we have an exact number
-        of characters to read.  */
-#ifdef USE_WIDE_CHAR
-      if (*str < L'0' || *str > L'9')
-       ++str;
-#else
-      if (*str < '0' || *str > '9')
-       {
-         int inner = 0;
-         if (thousands != NULL && *str == *thousands
-             && ({ for (inner = 1; thousands[inner] != '\0'; ++inner)
-                     if (thousands[inner] != str[inner])
-                       break;
-                   thousands[inner] == '\0'; }))
-           str += inner;
-         else
-           str += decimal_len;
-       }
-#endif
-      low = low * 10 + *str++ - L_('0');
-      ++cnt;
-    }
-  while (--digcnt > 0);
-
-  if (*exponent > 0 && cnt + *exponent <= MAX_DIG_PER_LIMB)
-    {
-      low *= _tens_in_limb[*exponent];
-      start = _tens_in_limb[cnt + *exponent];
-      *exponent = 0;
-    }
-  else
-    start = _tens_in_limb[cnt];
-
-  if (*nsize == 0)
-    {
-      n[0] = low;
-      *nsize = 1;
-    }
-  else
-    {
-      mp_limb_t cy;
-      cy = __mpn_mul_1 (n, n, *nsize, start);
-      cy += __mpn_add_1 (n, n, *nsize, low);
-      if (cy != 0)
-       n[(*nsize)++] = cy;
-    }
-
-  return str;
-}
-
-
-/* Shift {PTR, SIZE} COUNT bits to the left, and fill the vacated bits
-   with the COUNT most significant bits of LIMB.
-
-   Tege doesn't like this function so I have to write it here myself. :)
-   --drepper */
-static inline void
-__attribute ((always_inline))
-__mpn_lshift_1 (mp_limb_t *ptr, mp_size_t size, unsigned int count,
-               mp_limb_t limb)
-{
-  if (__builtin_constant_p (count) && count == BITS_PER_MP_LIMB)
-    {
-      /* Optimize the case of shifting by exactly a word:
-        just copy words, with no actual bit-shifting.  */
-      mp_size_t i;
-      for (i = size - 1; i > 0; --i)
-       ptr[i] = ptr[i - 1];
-      ptr[0] = limb;
-    }
-  else
-    {
-      (void) __mpn_lshift (ptr, ptr, size, count);
-      ptr[0] |= limb >> (BITS_PER_MP_LIMB - count);
-    }
-}
-
-
 #define INTERNAL(x) INTERNAL1(x)
 #define INTERNAL1(x) __##x##_internal
 
-/* This file defines a function to check for correct grouping.  */
-#include "grouping.h"
 
-
-/* Return a floating point number with the value of the given string NPTR.
-   Set *ENDPTR to the character after the last used one.  If the number is
-   smaller than the smallest representable number, set `errno' to ERANGE and
-   return 0.0.  If the number is too big to be represented, set `errno' to
-   ERANGE and return HUGE_VAL with the appropriate sign.  */
 FLOAT
-INTERNAL (STRTOF) (nptr, endptr, group LOCALE_PARAM)
+INTERNAL (STRTOF) (nptr, endptr, group)
      const STRING_TYPE *nptr;
      STRING_TYPE **endptr;
      int group;
-     LOCALE_PARAM_DECL
 {
-  int negative;                        /* The sign of the number.  */
-  MPN_VAR (num);               /* MP representation of the number.  */
-  int exponent;                        /* Exponent of the number.  */
-
-  /* Numbers starting `0X' or `0x' have to be processed with base 16.  */
-  int base = 10;
-
-  /* When we have to compute fractional digits we form a fraction with a
-     second multi-precision number (and we sometimes need a second for
-     temporary results).  */
-  MPN_VAR (den);
-
-  /* Representation for the return value.  */
-  mp_limb_t retval[RETURN_LIMB_SIZE];
-  /* Number of bits currently in result value.  */
-  int bits;
-
-  /* Running pointer after the last character processed in the string.  */
-  const STRING_TYPE *cp, *tp;
-  /* Start of significant part of the number.  */
-  const STRING_TYPE *startp, *start_of_digits;
-  /* Points at the character following the integer and fractional digits.  */
-  const STRING_TYPE *expp;
-  /* Total number of digit and number of digits in integer part.  */
-  int dig_no, int_no, lead_zero;
-  /* Contains the last character read.  */
-  CHAR_TYPE c;
-
-/* We should get wint_t from <stddef.h>, but not all GCC versions define it
-   there.  So define it ourselves if it remains undefined.  */
-#ifndef _WINT_T
-  typedef unsigned int wint_t;
-#endif
-  /* The radix character of the current locale.  */
-#ifdef USE_WIDE_CHAR
-  wchar_t decimal;
-#else
-  const char *decimal;
-  size_t decimal_len;
-#endif
-  /* The thousands character of the current locale.  */
-#ifdef USE_WIDE_CHAR
-  wchar_t thousands = L'\0';
-#else
-  const char *thousands = NULL;
-#endif
-  /* The numeric grouping specification of the current locale,
-     in the format described in <locale.h>.  */
-  const char *grouping;
-  /* Used in several places.  */
-  int cnt;
-
-#ifdef USE_IN_EXTENDED_LOCALE_MODEL
-  struct locale_data *current = loc->__locales[LC_NUMERIC];
-#endif
-
-  if (group)
-    {
-      grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
-      if (*grouping <= 0 || *grouping == CHAR_MAX)
-       grouping = NULL;
-      else
-       {
-         /* Figure out the thousands separator character.  */
-#ifdef USE_WIDE_CHAR
-         thousands = _NL_CURRENT_WORD (LC_NUMERIC,
-                                       _NL_NUMERIC_THOUSANDS_SEP_WC);
-         if (thousands == L'\0')
-           grouping = NULL;
-#else
-         thousands = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
-         if (*thousands == '\0')
-           {
-             thousands = NULL;
-             grouping = NULL;
-           }
-#endif
-       }
-    }
-  else
-    grouping = NULL;
-
-  /* Find the locale's decimal point character.  */
-#ifdef USE_WIDE_CHAR
-  decimal = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
-  assert (decimal != L'\0');
-# define decimal_len 1
-#else
-  decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
-  decimal_len = strlen (decimal);
-  assert (decimal_len > 0);
-#endif
-
-  /* Prepare number representation.  */
-  exponent = 0;
-  negative = 0;
-  bits = 0;
-
-  /* Parse string to get maximal legal prefix.  We need the number of
-     characters of the integer part, the fractional part and the exponent.  */
-  cp = nptr - 1;
-  /* Ignore leading white space.  */
-  do
-    c = *++cp;
-  while (ISSPACE (c));
-
-  /* Get sign of the result.  */
-  if (c == L_('-'))
-    {
-      negative = 1;
-      c = *++cp;
-    }
-  else if (c == L_('+'))
-    c = *++cp;
-
-  /* Return 0.0 if no legal string is found.
-     No character is used even if a sign was found.  */
-#ifdef USE_WIDE_CHAR
-  if (c == (wint_t) decimal
-      && (wint_t) cp[1] >= L'0' && (wint_t) cp[1] <= L'9')
-    {
-      /* We accept it.  This funny construct is here only to indent
-        the code directly.  */
-    }
-#else
-  for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
-    if (cp[cnt] != decimal[cnt])
-      break;
-  if (decimal[cnt] == '\0' && cp[cnt] >= '0' && cp[cnt] <= '9')
-    {
-      /* We accept it.  This funny construct is here only to indent
-        the code directly.  */
-    }
-#endif
-  else if (c < L_('0') || c > L_('9'))
-    {
-      /* Check for `INF' or `INFINITY'.  */
-      if (TOLOWER (c) == L_('i') && STRNCASECMP (cp, L_("inf"), 3) == 0)
-       {
-         /* Return +/- infinity.  */
-         if (endptr != NULL)
-           *endptr = (STRING_TYPE *)
-                     (cp + (STRNCASECMP (cp + 3, L_("inity"), 5) == 0
-                            ? 8 : 3));
-
-         return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
-       }
-
-      if (TOLOWER (c) == L_('n') && STRNCASECMP (cp, L_("nan"), 3) == 0)
-       {
-         /* Return NaN.  */
-         FLOAT retval = NAN;
-
-         cp += 3;
-
-         /* Match `(n-char-sequence-digit)'.  */
-         if (*cp == L_('('))
-           {
-             const STRING_TYPE *startp = cp;
-             do
-               ++cp;
-             while ((*cp >= L_('0') && *cp <= L_('9'))
-                    || (TOLOWER (*cp) >= L_('a') && TOLOWER (*cp) <= L_('z'))
-                    || *cp == L_('_'));
-
-             if (*cp != L_(')'))
-               /* The closing brace is missing.  Only match the NAN
-                  part.  */
-               cp = startp;
-             else
-               {
-                 /* This is a system-dependent way to specify the
-                    bitmask used for the NaN.  We expect it to be
-                    a number which is put in the mantissa of the
-                    number.  */
-                 STRING_TYPE *endp;
-                 unsigned long long int mant;
-
-                 mant = STRTOULL (startp + 1, &endp, 0);
-                 if (endp == cp)
-                   SET_MANTISSA (retval, mant);
-               }
-           }
-
-         if (endptr != NULL)
-           *endptr = (STRING_TYPE *) cp;
-
-         return retval;
-       }
-
-      /* It is really a text we do not recognize.  */
-      RETURN (0.0, nptr);
-    }
-
-  /* First look whether we are faced with a hexadecimal number.  */
-  if (c == L_('0') && TOLOWER (cp[1]) == L_('x'))
-    {
-      /* Okay, it is a hexa-decimal number.  Remember this and skip
-        the characters.  BTW: hexadecimal numbers must not be
-        grouped.  */
-      base = 16;
-      cp += 2;
-      c = *cp;
-      grouping = NULL;
-    }
-
-  /* Record the start of the digits, in case we will check their grouping.  */
-  start_of_digits = startp = cp;
-
-  /* Ignore leading zeroes.  This helps us to avoid useless computations.  */
-#ifdef USE_WIDE_CHAR
-  while (c == L'0' || ((wint_t) thousands != L'\0' && c == (wint_t) thousands))
-    c = *++cp;
-#else
-  if (thousands == NULL)
-    while (c == '0')
-      c = *++cp;
-  else
-    {
-      /* We also have the multibyte thousands string.  */
-      while (1)
-       {
-         if (c != '0')
-           {
-             for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
-               if (c != thousands[cnt])
-                 break;
-             if (thousands[cnt] != '\0')
-               break;
-           }
-         c = *++cp;
-       }
-    }
-#endif
-
-  /* If no other digit but a '0' is found the result is 0.0.
-     Return current read pointer.  */
-  if ((c < L_('0') || c > L_('9'))
-      && (base == 16 && (c < (CHAR_TYPE) TOLOWER (L_('a'))
-                        || c > (CHAR_TYPE) TOLOWER (L_('f'))))
-#ifdef USE_WIDE_CHAR
-      && c != (wint_t) decimal
-#else
-      && ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
-             if (decimal[cnt] != cp[cnt])
-               break;
-           decimal[cnt] != '\0'; })
-#endif
-      && (base == 16 && (cp == start_of_digits
-                        || (CHAR_TYPE) TOLOWER (c) != L_('p')))
-      && (base != 16 && (CHAR_TYPE) TOLOWER (c) != L_('e')))
-    {
-#ifdef USE_WIDE_CHAR
-      tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
-                                        grouping);
-#else
-      tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
-                                        grouping);
-#endif
-      /* If TP is at the start of the digits, there was no correctly
-        grouped prefix of the string; so no number found.  */
-      RETURN (0.0, tp == start_of_digits ? (base == 16 ? cp - 1 : nptr) : tp);
-    }
-
-  /* Remember first significant digit and read following characters until the
-     decimal point, exponent character or any non-FP number character.  */
-  startp = cp;
-  dig_no = 0;
-  while (1)
-    {
-      if ((c >= L_('0') && c <= L_('9'))
-         || (base == 16 && (wint_t) TOLOWER (c) >= L_('a')
-             && (wint_t) TOLOWER (c) <= L_('f')))
-       ++dig_no;
-      else
-       {
-#ifdef USE_WIDE_CHAR
-         if ((wint_t) thousands == L'\0' || c != (wint_t) thousands)
-           /* Not a digit or separator: end of the integer part.  */
-           break;
-#else
-         if (thousands == NULL)
-           break;
-         else
-           {
-             for (cnt = 0; thousands[cnt] != '\0'; ++cnt)
-               if (thousands[cnt] != cp[cnt])
-                 break;
-             if (thousands[cnt] != '\0')
-               break;
-           }
-#endif
-       }
-      c = *++cp;
-    }
-
-  if (grouping && dig_no > 0)
-    {
-      /* Check the grouping of the digits.  */
-#ifdef USE_WIDE_CHAR
-      tp = __correctly_grouped_prefixwc (start_of_digits, cp, thousands,
-                                        grouping);
-#else
-      tp = __correctly_grouped_prefixmb (start_of_digits, cp, thousands,
-                                        grouping);
-#endif
-      if (cp != tp)
-        {
-         /* Less than the entire string was correctly grouped.  */
-
-         if (tp == start_of_digits)
-           /* No valid group of numbers at all: no valid number.  */
-           RETURN (0.0, nptr);
-
-         if (tp < startp)
-           /* The number is validly grouped, but consists
-              only of zeroes.  The whole value is zero.  */
-           RETURN (0.0, tp);
-
-         /* Recompute DIG_NO so we won't read more digits than
-            are properly grouped.  */
-         cp = tp;
-         dig_no = 0;
-         for (tp = startp; tp < cp; ++tp)
-           if (*tp >= L_('0') && *tp <= L_('9'))
-             ++dig_no;
-
-         int_no = dig_no;
-         lead_zero = 0;
-
-         goto number_parsed;
-       }
-    }
-
-  /* We have the number digits in the integer part.  Whether these are all or
-     any is really a fractional digit will be decided later.  */
-  int_no = dig_no;
-  lead_zero = int_no == 0 ? -1 : 0;
-
-  /* Read the fractional digits.  A special case are the 'american style'
-     numbers like `16.' i.e. with decimal but without trailing digits.  */
-  if (
-#ifdef USE_WIDE_CHAR
-      c == (wint_t) decimal
-#else
-      ({ for (cnt = 0; decimal[cnt] != '\0'; ++cnt)
-          if (decimal[cnt] != cp[cnt])
-            break;
-        decimal[cnt] == '\0'; })
-#endif
-      )
-    {
-      cp += decimal_len;
-      c = *cp;
-      while ((c >= L_('0') && c <= L_('9')) ||
-            (base == 16 && TOLOWER (c) >= L_('a') && TOLOWER (c) <= L_('f')))
-       {
-         if (c != L_('0') && lead_zero == -1)
-           lead_zero = dig_no - int_no;
-         ++dig_no;
-         c = *++cp;
-       }
-    }
-
-  /* Remember start of exponent (if any).  */
-  expp = cp;
-
-  /* Read exponent.  */
-  if ((base == 16 && TOLOWER (c) == L_('p'))
-      || (base != 16 && TOLOWER (c) == L_('e')))
-    {
-      int exp_negative = 0;
-
-      c = *++cp;
-      if (c == L_('-'))
-       {
-         exp_negative = 1;
-         c = *++cp;
-       }
-      else if (c == L_('+'))
-       c = *++cp;
-
-      if (c >= L_('0') && c <= L_('9'))
-       {
-         int exp_limit;
-
-         /* Get the exponent limit. */
-         if (base == 16)
-           exp_limit = (exp_negative ?
-                        -MIN_EXP + MANT_DIG + 4 * int_no :
-                        MAX_EXP - 4 * int_no + lead_zero);
-         else
-           exp_limit = (exp_negative ?
-                        -MIN_10_EXP + MANT_DIG + int_no :
-                        MAX_10_EXP - int_no + lead_zero);
-
-         do
-           {
-             exponent *= 10;
-
-             if (exponent > exp_limit)
-               /* The exponent is too large/small to represent a valid
-                  number.  */
-               {
-                 FLOAT result;
-
-                 /* We have to take care for special situation: a joker
-                    might have written "0.0e100000" which is in fact
-                    zero.  */
-                 if (lead_zero == -1)
-                   result = negative ? -0.0 : 0.0;
-                 else
-                   {
-                     /* Overflow or underflow.  */
-                     __set_errno (ERANGE);
-                     result = (exp_negative ? 0.0 :
-                               negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL);
-                   }
-
-                 /* Accept all following digits as part of the exponent.  */
-                 do
-                   ++cp;
-                 while (*cp >= L_('0') && *cp <= L_('9'));
-
-                 RETURN (result, cp);
-                 /* NOTREACHED */
-               }
-
-             exponent += c - L_('0');
-             c = *++cp;
-           }
-         while (c >= L_('0') && c <= L_('9'));
-
-         if (exp_negative)
-           exponent = -exponent;
-       }
-      else
-       cp = expp;
-    }
-
-  /* We don't want to have to work with trailing zeroes after the radix.  */
-  if (dig_no > int_no)
-    {
-      while (expp[-1] == L_('0'))
-       {
-         --expp;
-         --dig_no;
-       }
-      assert (dig_no >= int_no);
-    }
-
-  if (dig_no == int_no && dig_no > 0 && exponent < 0)
-    do
-      {
-       while (! (base == 16 ? ISXDIGIT (expp[-1]) : ISDIGIT (expp[-1])))
-         --expp;
-
-       if (expp[-1] != L_('0'))
-         break;
-
-       --expp;
-       --dig_no;
-       --int_no;
-       ++exponent;
-      }
-    while (dig_no > 0 && exponent < 0);
-
- number_parsed:
-
-  /* The whole string is parsed.  Store the address of the next character.  */
-  if (endptr)
-    *endptr = (STRING_TYPE *) cp;
-
-  if (dig_no == 0)
-    return negative ? -0.0 : 0.0;
-
-  if (lead_zero)
-    {
-      /* Find the decimal point */
-#ifdef USE_WIDE_CHAR
-      while (*startp != decimal)
-       ++startp;
-#else
-      while (1)
-       {
-         if (*startp == decimal[0])
-           {
-             for (cnt = 1; decimal[cnt] != '\0'; ++cnt)
-               if (decimal[cnt] != startp[cnt])
-                 break;
-             if (decimal[cnt] == '\0')
-               break;
-           }
-         ++startp;
-       }
-#endif
-      startp += lead_zero + decimal_len;
-      exponent -= base == 16 ? 4 * lead_zero : lead_zero;
-      dig_no -= lead_zero;
-    }
-
-  /* If the BASE is 16 we can use a simpler algorithm.  */
-  if (base == 16)
-    {
-      static const int nbits[16] = { 0, 1, 2, 2, 3, 3, 3, 3,
-                                    4, 4, 4, 4, 4, 4, 4, 4 };
-      int idx = (MANT_DIG - 1) / BITS_PER_MP_LIMB;
-      int pos = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
-      mp_limb_t val;
-
-      while (!ISXDIGIT (*startp))
-       ++startp;
-      while (*startp == L_('0'))
-       ++startp;
-      if (ISDIGIT (*startp))
-       val = *startp++ - L_('0');
-      else
-       val = 10 + TOLOWER (*startp++) - L_('a');
-      bits = nbits[val];
-      /* We cannot have a leading zero.  */
-      assert (bits != 0);
-
-      if (pos + 1 >= 4 || pos + 1 >= bits)
-       {
-         /* We don't have to care for wrapping.  This is the normal
-            case so we add the first clause in the `if' expression as
-            an optimization.  It is a compile-time constant and so does
-            not cost anything.  */
-         retval[idx] = val << (pos - bits + 1);
-         pos -= bits;
-       }
-      else
-       {
-         retval[idx--] = val >> (bits - pos - 1);
-         retval[idx] = val << (BITS_PER_MP_LIMB - (bits - pos - 1));
-         pos = BITS_PER_MP_LIMB - 1 - (bits - pos - 1);
-       }
-
-      /* Adjust the exponent for the bits we are shifting in.  */
-      exponent += bits - 1 + (int_no - 1) * 4;
-
-      while (--dig_no > 0 && idx >= 0)
-       {
-         if (!ISXDIGIT (*startp))
-           startp += decimal_len;
-         if (ISDIGIT (*startp))
-           val = *startp++ - L_('0');
-         else
-           val = 10 + TOLOWER (*startp++) - L_('a');
-
-         if (pos + 1 >= 4)
-           {
-             retval[idx] |= val << (pos - 4 + 1);
-             pos -= 4;
-           }
-         else
-           {
-             retval[idx--] |= val >> (4 - pos - 1);
-             val <<= BITS_PER_MP_LIMB - (4 - pos - 1);
-             if (idx < 0)
-               return round_and_return (retval, exponent, negative, val,
-                                        BITS_PER_MP_LIMB - 1, dig_no > 0);
-
-             retval[idx] = val;
-             pos = BITS_PER_MP_LIMB - 1 - (4 - pos - 1);
-           }
-       }
-
-      /* We ran out of digits.  */
-      MPN_ZERO (retval, idx);
-
-      return round_and_return (retval, exponent, negative, 0, 0, 0);
-    }
-
-  /* Now we have the number of digits in total and the integer digits as well
-     as the exponent and its sign.  We can decide whether the read digits are
-     really integer digits or belong to the fractional part; i.e. we normalize
-     123e-2 to 1.23.  */
-  {
-    register int incr = (exponent < 0 ? MAX (-int_no, exponent)
-                        : MIN (dig_no - int_no, exponent));
-    int_no += incr;
-    exponent -= incr;
-  }
-
-  if (int_no + exponent > MAX_10_EXP + 1)
-    {
-      __set_errno (ERANGE);
-      return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
-    }
-
-  if (exponent < MIN_10_EXP - (DIG + 1))
-    {
-      __set_errno (ERANGE);
-      return 0.0;
-    }
-
-  if (int_no > 0)
-    {
-      /* Read the integer part as a multi-precision number to NUM.  */
-      startp = str_to_mpn (startp, int_no, num, &numsize, &exponent
-#ifndef USE_WIDE_CHAR
-                          , decimal, decimal_len, thousands
-#endif
-                          );
-
-      if (exponent > 0)
-       {
-         /* We now multiply the gained number by the given power of ten.  */
-         mp_limb_t *psrc = num;
-         mp_limb_t *pdest = den;
-         int expbit = 1;
-         const struct mp_power *ttab = &_fpioconst_pow10[0];
-
-         do
-           {
-             if ((exponent & expbit) != 0)
-               {
-                 size_t size = ttab->arraysize - _FPIO_CONST_OFFSET;
-                 mp_limb_t cy;
-                 exponent ^= expbit;
-
-                 /* FIXME: not the whole multiplication has to be
-                    done.  If we have the needed number of bits we
-                    only need the information whether more non-zero
-                    bits follow.  */
-                 if (numsize >= ttab->arraysize - _FPIO_CONST_OFFSET)
-                   cy = __mpn_mul (pdest, psrc, numsize,
-                                   &__tens[ttab->arrayoff
-                                          + _FPIO_CONST_OFFSET],
-                                   size);
-                 else
-                   cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
-                                                 + _FPIO_CONST_OFFSET],
-                                   size, psrc, numsize);
-                 numsize += size;
-                 if (cy == 0)
-                   --numsize;
-                 (void) SWAP (psrc, pdest);
-               }
-             expbit <<= 1;
-             ++ttab;
-           }
-         while (exponent != 0);
-
-         if (psrc == den)
-           memcpy (num, den, numsize * sizeof (mp_limb_t));
-       }
-
-      /* Determine how many bits of the result we already have.  */
-      count_leading_zeros (bits, num[numsize - 1]);
-      bits = numsize * BITS_PER_MP_LIMB - bits;
-
-      /* Now we know the exponent of the number in base two.
-        Check it against the maximum possible exponent.  */
-      if (bits > MAX_EXP)
-       {
-         __set_errno (ERANGE);
-         return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
-       }
-
-      /* We have already the first BITS bits of the result.  Together with
-        the information whether more non-zero bits follow this is enough
-        to determine the result.  */
-      if (bits > MANT_DIG)
-       {
-         int i;
-         const mp_size_t least_idx = (bits - MANT_DIG) / BITS_PER_MP_LIMB;
-         const mp_size_t least_bit = (bits - MANT_DIG) % BITS_PER_MP_LIMB;
-         const mp_size_t round_idx = least_bit == 0 ? least_idx - 1
-                                                    : least_idx;
-         const mp_size_t round_bit = least_bit == 0 ? BITS_PER_MP_LIMB - 1
-                                                    : least_bit - 1;
-
-         if (least_bit == 0)
-           memcpy (retval, &num[least_idx],
-                   RETURN_LIMB_SIZE * sizeof (mp_limb_t));
-         else
-            {
-              for (i = least_idx; i < numsize - 1; ++i)
-                retval[i - least_idx] = (num[i] >> least_bit)
-                                        | (num[i + 1]
-                                           << (BITS_PER_MP_LIMB - least_bit));
-              if (i - least_idx < RETURN_LIMB_SIZE)
-                retval[RETURN_LIMB_SIZE - 1] = num[i] >> least_bit;
-            }
-
-         /* Check whether any limb beside the ones in RETVAL are non-zero.  */
-         for (i = 0; num[i] == 0; ++i)
-           ;
-
-         return round_and_return (retval, bits - 1, negative,
-                                  num[round_idx], round_bit,
-                                  int_no < dig_no || i < round_idx);
-         /* NOTREACHED */
-       }
-      else if (dig_no == int_no)
-       {
-         const mp_size_t target_bit = (MANT_DIG - 1) % BITS_PER_MP_LIMB;
-         const mp_size_t is_bit = (bits - 1) % BITS_PER_MP_LIMB;
-
-         if (target_bit == is_bit)
-           {
-             memcpy (&retval[RETURN_LIMB_SIZE - numsize], num,
-                     numsize * sizeof (mp_limb_t));
-             /* FIXME: the following loop can be avoided if we assume a
-                maximal MANT_DIG value.  */
-             MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
-           }
-         else if (target_bit > is_bit)
-           {
-             (void) __mpn_lshift (&retval[RETURN_LIMB_SIZE - numsize],
-                                  num, numsize, target_bit - is_bit);
-             /* FIXME: the following loop can be avoided if we assume a
-                maximal MANT_DIG value.  */
-             MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize);
-           }
-         else
-           {
-             mp_limb_t cy;
-             assert (numsize < RETURN_LIMB_SIZE);
-
-             cy = __mpn_rshift (&retval[RETURN_LIMB_SIZE - numsize],
-                                num, numsize, is_bit - target_bit);
-             retval[RETURN_LIMB_SIZE - numsize - 1] = cy;
-             /* FIXME: the following loop can be avoided if we assume a
-                maximal MANT_DIG value.  */
-             MPN_ZERO (retval, RETURN_LIMB_SIZE - numsize - 1);
-           }
-
-         return round_and_return (retval, bits - 1, negative, 0, 0, 0);
-         /* NOTREACHED */
-       }
-
-      /* Store the bits we already have.  */
-      memcpy (retval, num, numsize * sizeof (mp_limb_t));
-#if RETURN_LIMB_SIZE > 1
-      if (numsize < RETURN_LIMB_SIZE)
-        retval[numsize] = 0;
-#endif
-    }
-
-  /* We have to compute at least some of the fractional digits.  */
-  {
-    /* We construct a fraction and the result of the division gives us
-       the needed digits.  The denominator is 1.0 multiplied by the
-       exponent of the lowest digit; i.e. 0.123 gives 123 / 1000 and
-       123e-6 gives 123 / 1000000.  */
-
-    int expbit;
-    int neg_exp;
-    int more_bits;
-    mp_limb_t cy;
-    mp_limb_t *psrc = den;
-    mp_limb_t *pdest = num;
-    const struct mp_power *ttab = &_fpioconst_pow10[0];
-
-    assert (dig_no > int_no && exponent <= 0);
-
-
-    /* For the fractional part we need not process too many digits.  One
-       decimal digits gives us log_2(10) ~ 3.32 bits.  If we now compute
-                        ceil(BITS / 3) =: N
-       digits we should have enough bits for the result.  The remaining
-       decimal digits give us the information that more bits are following.
-       This can be used while rounding.  (Two added as a safety margin.)  */
-    if (dig_no - int_no > (MANT_DIG - bits + 2) / 3 + 2)
-      {
-        dig_no = int_no + (MANT_DIG - bits + 2) / 3 + 2;
-        more_bits = 1;
-      }
-    else
-      more_bits = 0;
-
-    neg_exp = dig_no - int_no - exponent;
-
-    /* Construct the denominator.  */
-    densize = 0;
-    expbit = 1;
-    do
-      {
-       if ((neg_exp & expbit) != 0)
-         {
-           mp_limb_t cy;
-           neg_exp ^= expbit;
-
-           if (densize == 0)
-             {
-               densize = ttab->arraysize - _FPIO_CONST_OFFSET;
-               memcpy (psrc, &__tens[ttab->arrayoff + _FPIO_CONST_OFFSET],
-                       densize * sizeof (mp_limb_t));
-             }
-           else
-             {
-               cy = __mpn_mul (pdest, &__tens[ttab->arrayoff
-                                             + _FPIO_CONST_OFFSET],
-                               ttab->arraysize - _FPIO_CONST_OFFSET,
-                               psrc, densize);
-               densize += ttab->arraysize - _FPIO_CONST_OFFSET;
-               if (cy == 0)
-                 --densize;
-               (void) SWAP (psrc, pdest);
-             }
-         }
-       expbit <<= 1;
-       ++ttab;
-      }
-    while (neg_exp != 0);
-
-    if (psrc == num)
-      memcpy (den, num, densize * sizeof (mp_limb_t));
-
-    /* Read the fractional digits from the string.  */
-    (void) str_to_mpn (startp, dig_no - int_no, num, &numsize, &exponent
-#ifndef USE_WIDE_CHAR
-                      , decimal, decimal_len, thousands
-#endif
-                      );
-
-    /* We now have to shift both numbers so that the highest bit in the
-       denominator is set.  In the same process we copy the numerator to
-       a high place in the array so that the division constructs the wanted
-       digits.  This is done by a "quasi fix point" number representation.
-
-       num:   ddddddddddd . 0000000000000000000000
-              |--- m ---|
-       den:                            ddddddddddd      n >= m
-                                       |--- n ---|
-     */
-
-    count_leading_zeros (cnt, den[densize - 1]);
-
-    if (cnt > 0)
-      {
-       /* Don't call `mpn_shift' with a count of zero since the specification
-          does not allow this.  */
-       (void) __mpn_lshift (den, den, densize, cnt);
-       cy = __mpn_lshift (num, num, numsize, cnt);
-       if (cy != 0)
-         num[numsize++] = cy;
-      }
-
-    /* Now we are ready for the division.  But it is not necessary to
-       do a full multi-precision division because we only need a small
-       number of bits for the result.  So we do not use __mpn_divmod
-       here but instead do the division here by hand and stop whenever
-       the needed number of bits is reached.  The code itself comes
-       from the GNU MP Library by Torbj\"orn Granlund.  */
-
-    exponent = bits;
-
-    switch (densize)
-      {
-      case 1:
-       {
-         mp_limb_t d, n, quot;
-         int used = 0;
-
-         n = num[0];
-         d = den[0];
-         assert (numsize == 1 && n < d);
-
-         do
-           {
-             udiv_qrnnd (quot, n, n, 0, d);
-
-#define got_limb                                                             \
-             if (bits == 0)                                                  \
-               {                                                             \
-                 register int cnt;                                           \
-                 if (quot == 0)                                              \
-                   cnt = BITS_PER_MP_LIMB;                                   \
-                 else                                                        \
-                   count_leading_zeros (cnt, quot);                          \
-                 exponent -= cnt;                                            \
-                 if (BITS_PER_MP_LIMB - cnt > MANT_DIG)                      \
-                   {                                                         \
-                     used = MANT_DIG + cnt;                                  \
-                     retval[0] = quot >> (BITS_PER_MP_LIMB - used);          \
-                     bits = MANT_DIG + 1;                                    \
-                   }                                                         \
-                 else                                                        \
-                   {                                                         \
-                     /* Note that we only clear the second element.  */      \
-                     /* The conditional is determined at compile time.  */   \
-                     if (RETURN_LIMB_SIZE > 1)                               \
-                       retval[1] = 0;                                        \
-                     retval[0] = quot;                                       \
-                     bits = -cnt;                                            \
-                   }                                                         \
-               }                                                             \
-             else if (bits + BITS_PER_MP_LIMB <= MANT_DIG)                   \
-               __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, BITS_PER_MP_LIMB,   \
-                               quot);                                        \
-             else                                                            \
-               {                                                             \
-                 used = MANT_DIG - bits;                                     \
-                 if (used > 0)                                               \
-                   __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, quot);    \
-               }                                                             \
-             bits += BITS_PER_MP_LIMB
-
-             got_limb;
-           }
-         while (bits <= MANT_DIG);
-
-         return round_and_return (retval, exponent - 1, negative,
-                                  quot, BITS_PER_MP_LIMB - 1 - used,
-                                  more_bits || n != 0);
-       }
-      case 2:
-       {
-         mp_limb_t d0, d1, n0, n1;
-         mp_limb_t quot = 0;
-         int used = 0;
-
-         d0 = den[0];
-         d1 = den[1];
-
-         if (numsize < densize)
-           {
-             if (num[0] >= d1)
-               {
-                 /* The numerator of the number occupies fewer bits than
-                    the denominator but the one limb is bigger than the
-                    high limb of the numerator.  */
-                 n1 = 0;
-                 n0 = num[0];
-               }
-             else
-               {
-                 if (bits <= 0)
-                   exponent -= BITS_PER_MP_LIMB;
-                 else
-                   {
-                     if (bits + BITS_PER_MP_LIMB <= MANT_DIG)
-                       __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
-                                       BITS_PER_MP_LIMB, 0);
-                     else
-                       {
-                         used = MANT_DIG - bits;
-                         if (used > 0)
-                           __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
-                       }
-                     bits += BITS_PER_MP_LIMB;
-                   }
-                 n1 = num[0];
-                 n0 = 0;
-               }
-           }
-         else
-           {
-             n1 = num[1];
-             n0 = num[0];
-           }
-
-         while (bits <= MANT_DIG)
-           {
-             mp_limb_t r;
-
-             if (n1 == d1)
-               {
-                 /* QUOT should be either 111..111 or 111..110.  We need
-                    special treatment of this rare case as normal division
-                    would give overflow.  */
-                 quot = ~(mp_limb_t) 0;
-
-                 r = n0 + d1;
-                 if (r < d1)   /* Carry in the addition?  */
-                   {
-                     add_ssaaaa (n1, n0, r - d0, 0, 0, d0);
-                     goto have_quot;
-                   }
-                 n1 = d0 - (d0 != 0);
-                 n0 = -d0;
-               }
-             else
-               {
-                 udiv_qrnnd (quot, r, n1, n0, d1);
-                 umul_ppmm (n1, n0, d0, quot);
-               }
-
-           q_test:
-             if (n1 > r || (n1 == r && n0 > 0))
-               {
-                 /* The estimated QUOT was too large.  */
-                 --quot;
-
-                 sub_ddmmss (n1, n0, n1, n0, 0, d0);
-                 r += d1;
-                 if (r >= d1)  /* If not carry, test QUOT again.  */
-                   goto q_test;
-               }
-             sub_ddmmss (n1, n0, r, 0, n1, n0);
-
-           have_quot:
-             got_limb;
-           }
-
-         return round_and_return (retval, exponent - 1, negative,
-                                  quot, BITS_PER_MP_LIMB - 1 - used,
-                                  more_bits || n1 != 0 || n0 != 0);
-       }
-      default:
-       {
-         int i;
-         mp_limb_t cy, dX, d1, n0, n1;
-         mp_limb_t quot = 0;
-         int used = 0;
-
-         dX = den[densize - 1];
-         d1 = den[densize - 2];
-
-         /* The division does not work if the upper limb of the two-limb
-            numerator is greater than the denominator.  */
-         if (__mpn_cmp (num, &den[densize - numsize], numsize) > 0)
-           num[numsize++] = 0;
-
-         if (numsize < densize)
-           {
-             mp_size_t empty = densize - numsize;
-
-             if (bits <= 0)
-               {
-                 register int i;
-                 for (i = numsize; i > 0; --i)
-                   num[i + empty] = num[i - 1];
-                 MPN_ZERO (num, empty + 1);
-                 exponent -= empty * BITS_PER_MP_LIMB;
-               }
-             else
-               {
-                 if (bits + empty * BITS_PER_MP_LIMB <= MANT_DIG)
-                   {
-                     /* We make a difference here because the compiler
-                        cannot optimize the `else' case that good and
-                        this reflects all currently used FLOAT types
-                        and GMP implementations.  */
-                     register int i;
-#if RETURN_LIMB_SIZE <= 2
-                     assert (empty == 1);
-                     __mpn_lshift_1 (retval, RETURN_LIMB_SIZE,
-                                     BITS_PER_MP_LIMB, 0);
-#else
-                     for (i = RETURN_LIMB_SIZE; i > empty; --i)
-                       retval[i] = retval[i - empty];
-#endif
-                     for (i = numsize; i > 0; --i)
-                       num[i + empty] = num[i - 1];
-                     MPN_ZERO (num, empty + 1);
-                   }
-                 else
-                   {
-                     used = MANT_DIG - bits;
-                     if (used >= BITS_PER_MP_LIMB)
-                       {
-                         register int i;
-                         (void) __mpn_lshift (&retval[used
-                                                      / BITS_PER_MP_LIMB],
-                                              retval, RETURN_LIMB_SIZE,
-                                              used % BITS_PER_MP_LIMB);
-                         for (i = used / BITS_PER_MP_LIMB; i >= 0; --i)
-                           retval[i] = 0;
-                       }
-                     else if (used > 0)
-                       __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, 0);
-                   }
-                 bits += empty * BITS_PER_MP_LIMB;
-               }
-           }
-         else
-           {
-             int i;
-             assert (numsize == densize);
-             for (i = numsize; i > 0; --i)
-               num[i] = num[i - 1];
-           }
-
-         den[densize] = 0;
-         n0 = num[densize];
-
-         while (bits <= MANT_DIG)
-           {
-             if (n0 == dX)
-               /* This might over-estimate QUOT, but it's probably not
-                  worth the extra code here to find out.  */
-               quot = ~(mp_limb_t) 0;
-             else
-               {
-                 mp_limb_t r;
-
-                 udiv_qrnnd (quot, r, n0, num[densize - 1], dX);
-                 umul_ppmm (n1, n0, d1, quot);
-
-                 while (n1 > r || (n1 == r && n0 > num[densize - 2]))
-                   {
-                     --quot;
-                     r += dX;
-                     if (r < dX) /* I.e. "carry in previous addition?" */
-                       break;
-                     n1 -= n0 < d1;
-                     n0 -= d1;
-                   }
-               }
-
-             /* Possible optimization: We already have (q * n0) and (1 * n1)
-                after the calculation of QUOT.  Taking advantage of this, we
-                could make this loop make two iterations less.  */
-
-             cy = __mpn_submul_1 (num, den, densize + 1, quot);
-
-             if (num[densize] != cy)
-               {
-                 cy = __mpn_add_n (num, num, den, densize);
-                 assert (cy != 0);
-                 --quot;
-               }
-             n0 = num[densize] = num[densize - 1];
-             for (i = densize - 1; i > 0; --i)
-               num[i] = num[i - 1];
-
-             got_limb;
-           }
-
-         for (i = densize; num[i] == 0 && i >= 0; --i)
-           ;
-         return round_and_return (retval, exponent - 1, negative,
-                                  quot, BITS_PER_MP_LIMB - 1 - used,
-                                  more_bits || i >= 0);
-       }
-      }
-  }
-
-  /* NOTREACHED */
+  return INTERNAL(STRTOF_L) (nptr, endptr, group, _NL_CURRENT_LOCALE);
 }
-#if defined _LIBC \
-    && !(defined USE_IN_EXTENDED_LOCALE_MODEL && defined USE_WIDE_CHAR)
+#if defined _LIBC
 libc_hidden_def (INTERNAL (STRTOF))
 #endif
-\f
-/* External user entry point.  */
+
 
 FLOAT
 #ifdef weak_function
 weak_function
 #endif
-STRTOF (nptr, endptr LOCALE_PARAM)
+STRTOF (nptr, endptr)
      const STRING_TYPE *nptr;
      STRING_TYPE **endptr;
-     LOCALE_PARAM_DECL
 {
-  return INTERNAL (STRTOF) (nptr, endptr, 0 LOCALE_PARAM);
+  return INTERNAL(STRTOF_L) (nptr, endptr, 0, _NL_CURRENT_LOCALE);
 }