/* Convert string representing a number to float value, using given locale.

   Copyright (C) 1997-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <bits/floatn.h>

#ifdef FLOAT

# define BUILD_DOUBLE 0

#else

# define BUILD_DOUBLE 1

#endif

#if BUILD_DOUBLE

# if __HAVE_FLOAT64 && !__HAVE_DISTINCT_FLOAT64

#  define strtof64_l __hide_strtof64_l

#  define wcstof64_l __hide_wcstof64_l

# endif

# if __HAVE_FLOAT32X && !__HAVE_DISTINCT_FLOAT32X

#  define strtof32x_l __hide_strtof32x_l

#  define wcstof32x_l __hide_wcstof32x_l

# endif

#endif

#include <locale.h>

extern double ____strtod_l_internal (const char *, char **, int, locale_t);

/* 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.  */

#ifndef FLOAT

# include <math_ldbl_opt.h>

# define FLOAT		double

# define FLT		DBL

# ifdef USE_WIDE_CHAR

#  define STRTOF	wcstod_l

#  define __STRTOF	__wcstod_l

#  define STRTOF_NAN	__wcstod_nan

# else

#  define STRTOF	strtod_l

#  define __STRTOF	__strtod_l

#  define STRTOF_NAN	__strtod_nan

# endif

# define MPN2FLOAT	__mpn_construct_double

# define FLOAT_HUGE_VAL	HUGE_VAL

#endif

/* End of configuration part.  */

#include <ctype.h>

#include <errno.h>

#include <float.h>

#include "../locale/localeinfo.h"

#include <math.h>

#include <math-barriers.h>

#include <math-narrow-eval.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <rounding-mode.h>

#include <tininess.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"

#include <assert.h>

/* We use this code 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 and

   _NL_CURRENT_WORD macros.  */

#undef _NL_CURRENT

#define _NL_CURRENT(category, item) \

  (current->values[_NL_ITEM_INDEX (item)].string)

#undef _NL_CURRENT_WORD

#define _NL_CURRENT_WORD(category, item) \

  ((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)

#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

# 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 TOLOWER_C(Ch) __towlower_l ((Ch), _nl_C_locobj_ptr)

# define STRNCASECMP(S1, S2, N) \

  __wcsncasecmp_l ((S1), (S2), (N), _nl_C_locobj_ptr)

#else

# define STRING_TYPE char

# define CHAR_TYPE char

# define L_(Ch) Ch

# 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 TOLOWER_C(Ch) __tolower_l ((Ch), _nl_C_locobj_ptr)

# define STRNCASECMP(S1, S2, N) \

  __strncasecmp_l ((S1), (S2), (N), _nl_C_locobj_ptr)

#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)

#define MAX_VALUE	PASTE(FLT,_MAX)

#define MIN_VALUE	PASTE(FLT,_MIN)

/* 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);

/* 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

extern const mp_limb_t _tens_in_limb[MAX_DIG_PER_LIMB + 1];

#ifndef	howmany

#define	howmany(x,y)		(((x)+((y)-1))/(y))

#endif

#define SWAP(x, y)		({ typeof(x) _tmp = x; x = y; y = _tmp; })

#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.  The largest number we need to hold is 10^n where 2^-n is

   1/4 ulp of the smallest representable value (that is, n = MANT_DIG

   - MIN_EXP + 2).  Approximate using 10^3 < 2^10.  */

#define	MPNSIZE		(howmany (1 + ((MANT_DIG - MIN_EXP + 2) * 10) / 3, \

				  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))

/* Set errno and return an overflowing value with sign specified by

   NEGATIVE.  */

static FLOAT

overflow_value (int negative)

{

  __set_errno (ERANGE);

  FLOAT result = math_narrow_eval ((negative ? -MAX_VALUE : MAX_VALUE)

				   * MAX_VALUE);

  return result;

}

/* Set errno and return an underflowing value with sign specified by

   NEGATIVE.  */

static FLOAT

underflow_value (int negative)

{

  __set_errno (ERANGE);

  FLOAT result = math_narrow_eval ((negative ? -MIN_VALUE : MIN_VALUE)

				   * MIN_VALUE);

  return result;

}

/* 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, intmax_t exponent, int negative,

		  mp_limb_t round_limb, mp_size_t round_bit, int more_bits)

{

  int mode = get_rounding_mode ();

  if (exponent < MIN_EXP - 1)

    {

      if (exponent < MIN_EXP - 1 - MANT_DIG)

	return underflow_value (negative);

      mp_size_t shift = MIN_EXP - 1 - exponent;

      bool is_tiny = true;

      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 - 1; ++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);

	  /* __mpn_rshift requires 0 < shift < BITS_PER_MP_LIMB.  */

	  if ((shift % BITS_PER_MP_LIMB) != 0)

	    (void) __mpn_rshift (retval, &retval[shift / BITS_PER_MP_LIMB],

			         RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB),

			         shift % BITS_PER_MP_LIMB);

	  else

	    for (i = 0; i < RETURN_LIMB_SIZE - (shift / BITS_PER_MP_LIMB); i++)

	      retval[i] = retval[i + (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)

	{

	  if (TININESS_AFTER_ROUNDING && shift == 1)

	    {

	      /* Whether the result counts as tiny depends on whether,

		 after rounding to the normal precision, it still has

		 a subnormal exponent.  */

	      mp_limb_t retval_normal[RETURN_LIMB_SIZE];

	      if (round_away (negative,

			      (retval[0] & 1) != 0,

			      (round_limb

			       & (((mp_limb_t) 1) << round_bit)) != 0,

			      (more_bits

			       || ((round_limb

				    & ((((mp_limb_t) 1) << round_bit) - 1))

				   != 0)),

			      mode))

		{

		  mp_limb_t cy = __mpn_add_1 (retval_normal, retval,

					      RETURN_LIMB_SIZE, 1);

		  if (((MANT_DIG % BITS_PER_MP_LIMB) == 0 && cy) ||

		      ((MANT_DIG % BITS_PER_MP_LIMB) != 0 &&

		       ((retval_normal[RETURN_LIMB_SIZE - 1]

			& (((mp_limb_t) 1) << (MANT_DIG % BITS_PER_MP_LIMB)))

			!= 0)))

		    is_tiny = false;

		}

	    }

	  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 (is_tiny

	  && ((round_limb & (((mp_limb_t) 1) << round_bit)) != 0

	      || more_bits

	      || (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0))

	{

	  __set_errno (ERANGE);

	  FLOAT force_underflow = MIN_VALUE * MIN_VALUE;

	  math_force_eval (force_underflow);

	}

    }

  if (exponent >= MAX_EXP)

    goto overflow;

  bool half_bit = (round_limb & (((mp_limb_t) 1) << round_bit)) != 0;

  bool more_bits_nonzero

    = (more_bits

       || (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0);

  if (round_away (negative,

		  (retval[0] & 1) != 0,

		  half_bit,

		  more_bits_nonzero,

		  mode))

    {

      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)

  overflow:

    return overflow_value (negative);

  if (half_bit || more_bits_nonzero)

    {

      FLOAT force_inexact = (FLOAT) 1 + MIN_VALUE;

      math_force_eval (force_inexact);

    }

  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,

	    intmax_t *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)

		{

		  assert (*nsize < MPNSIZE);

		  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 && *exponent <= MAX_DIG_PER_LIMB - cnt)

    {

      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)

	{

	  assert (*nsize < MPNSIZE);

	  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.

   Implemented as a macro, so that __builtin_constant_p works even at -O0.

   Tege doesn't like this macro so I have to write it here myself. :)

   --drepper */

#define __mpn_lshift_1(ptr, size, count, limb) \

  do									\

    {									\

      mp_limb_t *__ptr = (ptr);						\

      if (__builtin_constant_p (count) && count == BITS_PER_MP_LIMB)	\

	{								\

	  mp_size_t i;							\

	  for (i = (size) - 1; i > 0; --i)				\

	    __ptr[i] = __ptr[i - 1];					\

	  __ptr[0] = (limb);						\

	}								\

      else								\

	{								\

	  /* We assume count > 0 && count < BITS_PER_MP_LIMB here.  */	\

	  unsigned int __count = (count);				\

	  (void) __mpn_lshift (__ptr, __ptr, size, __count);		\

	  __ptr[0] |= (limb) >> (BITS_PER_MP_LIMB - __count);		\

	}								\

    }									\

  while (0)

#define INTERNAL(x) INTERNAL1(x)

#define INTERNAL1(x) __##x##_internal

#ifndef ____STRTOF_INTERNAL

# define ____STRTOF_INTERNAL INTERNAL (__STRTOF)

#endif

/* 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

____STRTOF_INTERNAL (const STRING_TYPE *nptr, STRING_TYPE **endptr, int group,

		     locale_t loc)

{

  int negative;			/* The sign of the number.  */

  MPN_VAR (num);		/* MP representation of the number.  */

  intmax_t 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.  */

  size_t 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;

  struct __locale_data *current = loc->__locales[LC_NUMERIC];

  if (__glibc_unlikely (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 correctly.  */

    }

#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 correctly.  */

    }

#endif

  else if (c < L_('0') || c > L_('9'))

    {

      /* Check for `INF' or `INFINITY'.  */

      CHAR_TYPE lowc = TOLOWER_C (c);

      if (lowc == 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 (lowc == 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;

	      STRING_TYPE *endp;

	      retval = STRTOF_NAN (cp + 1, &endp, L_(')'));

	      if (*endp == L_(')'))

		/* Consume the closing parenthesis.  */

		cp = endp + 1;

	      else

		/* Only match the NAN part.  */

		cp = startp;

	    }

	  if (endptr != NULL)

	    *endptr = (STRING_TYPE *) cp;

	  return negative ? -retval : 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 (__glibc_likely (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 (thousands[cnt] != cp[cnt])

		  break;

	      if (thousands[cnt] != '\0')

		break;

	      cp += cnt - 1;

	    }

	  c = *++cp;

	}

    }

#endif

  /* If no other digit but a '0' is found the result is 0.0.

     Return current read pointer.  */

  CHAR_TYPE lowc = TOLOWER (c);

  if (!((c >= L_('0') && c <= L_('9'))

	|| (base == 16 && lowc >= L_('a') && lowc <= 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

	    /* '0x.' alone is not a valid hexadecimal number.

	       '.' alone is not valid either, but that has been checked

	       already earlier.  */

	    && (base != 16

		|| cp != start_of_digits

		|| (cp[decimal_len] >= L_('0') && cp[decimal_len] <= L_('9'))

		|| ({ CHAR_TYPE lo = TOLOWER (cp[decimal_len]);

		      lo >= L_('a') && lo <= L_('f'); })))

	|| (base == 16 && (cp != start_of_digits

			   && lowc == L_('p')))

	|| (base != 16 && lowc == 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 (negative ? -0.0 : 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

	      && ({ CHAR_TYPE lo = TOLOWER (c);

		    lo >= L_('a') && lo <= L_('f'); })))

	++dig_no;

      else

	{

#ifdef USE_WIDE_CHAR

	  if (__builtin_expect ((wint_t) thousands == L'\0', 1)

	      || c != (wint_t) thousands)

	    /* Not a digit or separator: end of the integer part.  */

	    break;

#else

	  if (__glibc_likely (thousands == NULL))

	    break;

	  else

	    {

	      for (cnt = 0; thousands[cnt] != '\0'; ++cnt)

		if (thousands[cnt] != cp[cnt])

		  break;

	      if (thousands[cnt] != '\0')

		break;

	      cp += cnt - 1;

	    }

#endif

	}

      c = *++cp;

    }

  if (__builtin_expect (grouping != NULL, 0) && cp > start_of_digits)

    {

      /* 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 (negative ? -0.0 : 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 of 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 ? (size_t) -1 : 0;

  /* Read the fractional digits.  A special case are the 'american

     style' numbers like `16.' i.e. with decimal point 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 && ({ CHAR_TYPE lo = TOLOWER (c);

			       lo >= L_('a') && lo <= L_('f'); })))

	{

	  if (c != L_('0') && lead_zero == (size_t) -1)

	    lead_zero = dig_no - int_no;

	  ++dig_no;

	  c = *++cp;

	}

    }

  assert (dig_no <= (uintmax_t) INTMAX_MAX);

  /* Remember start of exponent (if any).  */

  expp = cp;

  /* Read exponent.  */

  lowc = TOLOWER (c);