1 /* Convert string representing a number to float value, using given locale.
2 Copyright (C) 1997-2015 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
22 extern double ____strtod_l_internal (const char *, char **, int, __locale_t
);
23 extern unsigned long long int ____strtoull_l_internal (const char *, char **,
24 int, int, __locale_t
);
26 /* Configuration part. These macros are defined by `strtold.c',
27 `strtof.c', `wcstod.c', `wcstold.c', and `wcstof.c' to produce the
28 `long double' and `float' versions of the reader. */
30 # include <math_ldbl_opt.h>
34 # define STRTOF wcstod_l
35 # define __STRTOF __wcstod_l
37 # define STRTOF strtod_l
38 # define __STRTOF __strtod_l
40 # define MPN2FLOAT __mpn_construct_double
41 # define FLOAT_HUGE_VAL HUGE_VAL
42 # define SET_MANTISSA(flt, mant) \
43 do { union ieee754_double u; \
45 u.ieee_nan.mantissa0 = (mant) >> 32; \
46 u.ieee_nan.mantissa1 = (mant); \
47 if ((u.ieee.mantissa0 | u.ieee.mantissa1) != 0) \
51 /* End of configuration part. */
57 #include "../locale/localeinfo.h"
60 #include <math_private.h>
64 #include <rounding-mode.h>
67 /* The gmp headers need some configuration frobs. */
70 /* Include gmp-mparam.h first, such that definitions of _SHORT_LIMB
71 and _LONG_LONG_LIMB in it can take effect into gmp.h. */
72 #include <gmp-mparam.h>
76 #include "fpioconst.h"
81 /* We use this code for the extended locale handling where the
82 function gets as an additional argument the locale which has to be
83 used. To access the values we have to redefine the _NL_CURRENT and
84 _NL_CURRENT_WORD macros. */
86 #define _NL_CURRENT(category, item) \
87 (current->values[_NL_ITEM_INDEX (item)].string)
88 #undef _NL_CURRENT_WORD
89 #define _NL_CURRENT_WORD(category, item) \
90 ((uint32_t) current->values[_NL_ITEM_INDEX (item)].word)
92 #if defined _LIBC || defined HAVE_WCHAR_H
98 # define STRING_TYPE wchar_t
99 # define CHAR_TYPE wint_t
100 # define L_(Ch) L##Ch
101 # define ISSPACE(Ch) __iswspace_l ((Ch), loc)
102 # define ISDIGIT(Ch) __iswdigit_l ((Ch), loc)
103 # define ISXDIGIT(Ch) __iswxdigit_l ((Ch), loc)
104 # define TOLOWER(Ch) __towlower_l ((Ch), loc)
105 # define TOLOWER_C(Ch) __towlower_l ((Ch), _nl_C_locobj_ptr)
106 # define STRNCASECMP(S1, S2, N) \
107 __wcsncasecmp_l ((S1), (S2), (N), _nl_C_locobj_ptr)
108 # define STRTOULL(S, E, B) ____wcstoull_l_internal ((S), (E), (B), 0, loc)
110 # define STRING_TYPE char
111 # define CHAR_TYPE char
113 # define ISSPACE(Ch) __isspace_l ((Ch), loc)
114 # define ISDIGIT(Ch) __isdigit_l ((Ch), loc)
115 # define ISXDIGIT(Ch) __isxdigit_l ((Ch), loc)
116 # define TOLOWER(Ch) __tolower_l ((Ch), loc)
117 # define TOLOWER_C(Ch) __tolower_l ((Ch), _nl_C_locobj_ptr)
118 # define STRNCASECMP(S1, S2, N) \
119 __strncasecmp_l ((S1), (S2), (N), _nl_C_locobj_ptr)
120 # define STRTOULL(S, E, B) ____strtoull_l_internal ((S), (E), (B), 0, loc)
124 /* Constants we need from float.h; select the set for the FLOAT precision. */
125 #define MANT_DIG PASTE(FLT,_MANT_DIG)
126 #define DIG PASTE(FLT,_DIG)
127 #define MAX_EXP PASTE(FLT,_MAX_EXP)
128 #define MIN_EXP PASTE(FLT,_MIN_EXP)
129 #define MAX_10_EXP PASTE(FLT,_MAX_10_EXP)
130 #define MIN_10_EXP PASTE(FLT,_MIN_10_EXP)
131 #define MAX_VALUE PASTE(FLT,_MAX)
132 #define MIN_VALUE PASTE(FLT,_MIN)
134 /* Extra macros required to get FLT expanded before the pasting. */
135 #define PASTE(a,b) PASTE1(a,b)
136 #define PASTE1(a,b) a##b
138 /* Function to construct a floating point number from an MP integer
139 containing the fraction bits, a base 2 exponent, and a sign flag. */
140 extern FLOAT
MPN2FLOAT (mp_srcptr mpn
, int exponent
, int negative
);
142 /* Definitions according to limb size used. */
143 #if BITS_PER_MP_LIMB == 32
144 # define MAX_DIG_PER_LIMB 9
145 # define MAX_FAC_PER_LIMB 1000000000UL
146 #elif BITS_PER_MP_LIMB == 64
147 # define MAX_DIG_PER_LIMB 19
148 # define MAX_FAC_PER_LIMB 10000000000000000000ULL
150 # error "mp_limb_t size " BITS_PER_MP_LIMB "not accounted for"
153 extern const mp_limb_t _tens_in_limb
[MAX_DIG_PER_LIMB
+ 1];
156 #define howmany(x,y) (((x)+((y)-1))/(y))
158 #define SWAP(x, y) ({ typeof(x) _tmp = x; x = y; y = _tmp; })
160 #define RETURN_LIMB_SIZE howmany (MANT_DIG, BITS_PER_MP_LIMB)
162 #define RETURN(val,end) \
163 do { if (endptr != NULL) *endptr = (STRING_TYPE *) (end); \
164 return val; } while (0)
166 /* Maximum size necessary for mpn integers to hold floating point
167 numbers. The largest number we need to hold is 10^n where 2^-n is
168 1/4 ulp of the smallest representable value (that is, n = MANT_DIG
169 - MIN_EXP + 2). Approximate using 10^3 < 2^10. */
170 #define MPNSIZE (howmany (1 + ((MANT_DIG - MIN_EXP + 2) * 10) / 3, \
171 BITS_PER_MP_LIMB) + 2)
172 /* Declare an mpn integer variable that big. */
173 #define MPN_VAR(name) mp_limb_t name[MPNSIZE]; mp_size_t name##size
174 /* Copy an mpn integer value. */
175 #define MPN_ASSIGN(dst, src) \
176 memcpy (dst, src, (dst##size = src##size) * sizeof (mp_limb_t))
179 /* Set errno and return an overflowing value with sign specified by
182 overflow_value (int negative
)
184 __set_errno (ERANGE
);
185 FLOAT result
= math_narrow_eval ((negative
? -MAX_VALUE
: MAX_VALUE
)
191 /* Set errno and return an underflowing value with sign specified by
194 underflow_value (int negative
)
196 __set_errno (ERANGE
);
197 FLOAT result
= math_narrow_eval ((negative
? -MIN_VALUE
: MIN_VALUE
)
203 /* Return a floating point number of the needed type according to the given
204 multi-precision number after possible rounding. */
206 round_and_return (mp_limb_t
*retval
, intmax_t exponent
, int negative
,
207 mp_limb_t round_limb
, mp_size_t round_bit
, int more_bits
)
209 int mode
= get_rounding_mode ();
211 if (exponent
< MIN_EXP
- 1)
213 if (exponent
< MIN_EXP
- 1 - MANT_DIG
)
214 return underflow_value (negative
);
216 mp_size_t shift
= MIN_EXP
- 1 - exponent
;
219 more_bits
|= (round_limb
& ((((mp_limb_t
) 1) << round_bit
) - 1)) != 0;
220 if (shift
== MANT_DIG
)
221 /* This is a special case to handle the very seldom case where
222 the mantissa will be empty after the shift. */
226 round_limb
= retval
[RETURN_LIMB_SIZE
- 1];
227 round_bit
= (MANT_DIG
- 1) % BITS_PER_MP_LIMB
;
228 for (i
= 0; i
< RETURN_LIMB_SIZE
- 1; ++i
)
229 more_bits
|= retval
[i
] != 0;
230 MPN_ZERO (retval
, RETURN_LIMB_SIZE
);
232 else if (shift
>= BITS_PER_MP_LIMB
)
236 round_limb
= retval
[(shift
- 1) / BITS_PER_MP_LIMB
];
237 round_bit
= (shift
- 1) % BITS_PER_MP_LIMB
;
238 for (i
= 0; i
< (shift
- 1) / BITS_PER_MP_LIMB
; ++i
)
239 more_bits
|= retval
[i
] != 0;
240 more_bits
|= ((round_limb
& ((((mp_limb_t
) 1) << round_bit
) - 1))
243 /* __mpn_rshift requires 0 < shift < BITS_PER_MP_LIMB. */
244 if ((shift
% BITS_PER_MP_LIMB
) != 0)
245 (void) __mpn_rshift (retval
, &retval
[shift
/ BITS_PER_MP_LIMB
],
246 RETURN_LIMB_SIZE
- (shift
/ BITS_PER_MP_LIMB
),
247 shift
% BITS_PER_MP_LIMB
);
249 for (i
= 0; i
< RETURN_LIMB_SIZE
- (shift
/ BITS_PER_MP_LIMB
); i
++)
250 retval
[i
] = retval
[i
+ (shift
/ BITS_PER_MP_LIMB
)];
251 MPN_ZERO (&retval
[RETURN_LIMB_SIZE
- (shift
/ BITS_PER_MP_LIMB
)],
252 shift
/ BITS_PER_MP_LIMB
);
256 if (TININESS_AFTER_ROUNDING
&& shift
== 1)
258 /* Whether the result counts as tiny depends on whether,
259 after rounding to the normal precision, it still has
260 a subnormal exponent. */
261 mp_limb_t retval_normal
[RETURN_LIMB_SIZE
];
262 if (round_away (negative
,
263 (retval
[0] & 1) != 0,
265 & (((mp_limb_t
) 1) << round_bit
)) != 0,
268 & ((((mp_limb_t
) 1) << round_bit
) - 1))
272 mp_limb_t cy
= __mpn_add_1 (retval_normal
, retval
,
273 RETURN_LIMB_SIZE
, 1);
275 if (((MANT_DIG
% BITS_PER_MP_LIMB
) == 0 && cy
) ||
276 ((MANT_DIG
% BITS_PER_MP_LIMB
) != 0 &&
277 ((retval_normal
[RETURN_LIMB_SIZE
- 1]
278 & (((mp_limb_t
) 1) << (MANT_DIG
% BITS_PER_MP_LIMB
)))
283 round_limb
= retval
[0];
284 round_bit
= shift
- 1;
285 (void) __mpn_rshift (retval
, retval
, RETURN_LIMB_SIZE
, shift
);
287 /* This is a hook for the m68k long double format, where the
288 exponent bias is the same for normalized and denormalized
291 # define DENORM_EXP (MIN_EXP - 2)
293 exponent
= DENORM_EXP
;
295 && ((round_limb
& (((mp_limb_t
) 1) << round_bit
)) != 0
297 || (round_limb
& ((((mp_limb_t
) 1) << round_bit
) - 1)) != 0))
299 __set_errno (ERANGE
);
300 FLOAT force_underflow
= MIN_VALUE
* MIN_VALUE
;
301 math_force_eval (force_underflow
);
305 if (exponent
> MAX_EXP
)
308 if (round_away (negative
,
309 (retval
[0] & 1) != 0,
310 (round_limb
& (((mp_limb_t
) 1) << round_bit
)) != 0,
312 || (round_limb
& ((((mp_limb_t
) 1) << round_bit
) - 1)) != 0),
315 mp_limb_t cy
= __mpn_add_1 (retval
, retval
, RETURN_LIMB_SIZE
, 1);
317 if (((MANT_DIG
% BITS_PER_MP_LIMB
) == 0 && cy
) ||
318 ((MANT_DIG
% BITS_PER_MP_LIMB
) != 0 &&
319 (retval
[RETURN_LIMB_SIZE
- 1]
320 & (((mp_limb_t
) 1) << (MANT_DIG
% BITS_PER_MP_LIMB
))) != 0))
323 (void) __mpn_rshift (retval
, retval
, RETURN_LIMB_SIZE
, 1);
324 retval
[RETURN_LIMB_SIZE
- 1]
325 |= ((mp_limb_t
) 1) << ((MANT_DIG
- 1) % BITS_PER_MP_LIMB
);
327 else if (exponent
== DENORM_EXP
328 && (retval
[RETURN_LIMB_SIZE
- 1]
329 & (((mp_limb_t
) 1) << ((MANT_DIG
- 1) % BITS_PER_MP_LIMB
)))
331 /* The number was denormalized but now normalized. */
332 exponent
= MIN_EXP
- 1;
335 if (exponent
> MAX_EXP
)
337 return overflow_value (negative
);
339 return MPN2FLOAT (retval
, exponent
, negative
);
343 /* Read a multi-precision integer starting at STR with exactly DIGCNT digits
344 into N. Return the size of the number limbs in NSIZE at the first
345 character od the string that is not part of the integer as the function
346 value. If the EXPONENT is small enough to be taken as an additional
347 factor for the resulting number (see code) multiply by it. */
348 static const STRING_TYPE
*
349 str_to_mpn (const STRING_TYPE
*str
, int digcnt
, mp_limb_t
*n
, mp_size_t
*nsize
,
351 #ifndef USE_WIDE_CHAR
352 , const char *decimal
, size_t decimal_len
, const char *thousands
357 /* Number of digits for actual limb. */
366 if (cnt
== MAX_DIG_PER_LIMB
)
376 cy
= __mpn_mul_1 (n
, n
, *nsize
, MAX_FAC_PER_LIMB
);
377 cy
+= __mpn_add_1 (n
, n
, *nsize
, low
);
380 assert (*nsize
< MPNSIZE
);
389 /* There might be thousands separators or radix characters in
390 the string. But these all can be ignored because we know the
391 format of the number is correct and we have an exact number
392 of characters to read. */
394 if (*str
< L
'0' || *str
> L
'9')
397 if (*str
< '0' || *str
> '9')
400 if (thousands
!= NULL
&& *str
== *thousands
401 && ({ for (inner
= 1; thousands
[inner
] != '\0'; ++inner
)
402 if (thousands
[inner
] != str
[inner
])
404 thousands
[inner
] == '\0'; }))
410 low
= low
* 10 + *str
++ - L_('0');
413 while (--digcnt
> 0);
415 if (*exponent
> 0 && *exponent
<= MAX_DIG_PER_LIMB
- cnt
)
417 low
*= _tens_in_limb
[*exponent
];
418 start
= _tens_in_limb
[cnt
+ *exponent
];
422 start
= _tens_in_limb
[cnt
];
432 cy
= __mpn_mul_1 (n
, n
, *nsize
, start
);
433 cy
+= __mpn_add_1 (n
, n
, *nsize
, low
);
436 assert (*nsize
< MPNSIZE
);
445 /* Shift {PTR, SIZE} COUNT bits to the left, and fill the vacated bits
446 with the COUNT most significant bits of LIMB.
448 Implemented as a macro, so that __builtin_constant_p works even at -O0.
450 Tege doesn't like this macro so I have to write it here myself. :)
452 #define __mpn_lshift_1(ptr, size, count, limb) \
455 mp_limb_t *__ptr = (ptr); \
456 if (__builtin_constant_p (count) && count == BITS_PER_MP_LIMB) \
459 for (i = (size) - 1; i > 0; --i) \
460 __ptr[i] = __ptr[i - 1]; \
465 /* We assume count > 0 && count < BITS_PER_MP_LIMB here. */ \
466 unsigned int __count = (count); \
467 (void) __mpn_lshift (__ptr, __ptr, size, __count); \
468 __ptr[0] |= (limb) >> (BITS_PER_MP_LIMB - __count); \
474 #define INTERNAL(x) INTERNAL1(x)
475 #define INTERNAL1(x) __##x##_internal
476 #ifndef ____STRTOF_INTERNAL
477 # define ____STRTOF_INTERNAL INTERNAL (__STRTOF)
480 /* This file defines a function to check for correct grouping. */
481 #include "grouping.h"
484 /* Return a floating point number with the value of the given string NPTR.
485 Set *ENDPTR to the character after the last used one. If the number is
486 smaller than the smallest representable number, set `errno' to ERANGE and
487 return 0.0. If the number is too big to be represented, set `errno' to
488 ERANGE and return HUGE_VAL with the appropriate sign. */
490 ____STRTOF_INTERNAL (nptr
, endptr
, group
, loc
)
491 const STRING_TYPE
*nptr
;
492 STRING_TYPE
**endptr
;
496 int negative
; /* The sign of the number. */
497 MPN_VAR (num
); /* MP representation of the number. */
498 intmax_t exponent
; /* Exponent of the number. */
500 /* Numbers starting `0X' or `0x' have to be processed with base 16. */
503 /* When we have to compute fractional digits we form a fraction with a
504 second multi-precision number (and we sometimes need a second for
505 temporary results). */
508 /* Representation for the return value. */
509 mp_limb_t retval
[RETURN_LIMB_SIZE
];
510 /* Number of bits currently in result value. */
513 /* Running pointer after the last character processed in the string. */
514 const STRING_TYPE
*cp
, *tp
;
515 /* Start of significant part of the number. */
516 const STRING_TYPE
*startp
, *start_of_digits
;
517 /* Points at the character following the integer and fractional digits. */
518 const STRING_TYPE
*expp
;
519 /* Total number of digit and number of digits in integer part. */
520 size_t dig_no
, int_no
, lead_zero
;
521 /* Contains the last character read. */
524 /* We should get wint_t from <stddef.h>, but not all GCC versions define it
525 there. So define it ourselves if it remains undefined. */
527 typedef unsigned int wint_t;
529 /* The radix character of the current locale. */
536 /* The thousands character of the current locale. */
538 wchar_t thousands
= L
'\0';
540 const char *thousands
= NULL
;
542 /* The numeric grouping specification of the current locale,
543 in the format described in <locale.h>. */
544 const char *grouping
;
545 /* Used in several places. */
548 struct __locale_data
*current
= loc
->__locales
[LC_NUMERIC
];
550 if (__glibc_unlikely (group
))
552 grouping
= _NL_CURRENT (LC_NUMERIC
, GROUPING
);
553 if (*grouping
<= 0 || *grouping
== CHAR_MAX
)
557 /* Figure out the thousands separator character. */
559 thousands
= _NL_CURRENT_WORD (LC_NUMERIC
,
560 _NL_NUMERIC_THOUSANDS_SEP_WC
);
561 if (thousands
== L
'\0')
564 thousands
= _NL_CURRENT (LC_NUMERIC
, THOUSANDS_SEP
);
565 if (*thousands
== '\0')
576 /* Find the locale's decimal point character. */
578 decimal
= _NL_CURRENT_WORD (LC_NUMERIC
, _NL_NUMERIC_DECIMAL_POINT_WC
);
579 assert (decimal
!= L
'\0');
580 # define decimal_len 1
582 decimal
= _NL_CURRENT (LC_NUMERIC
, DECIMAL_POINT
);
583 decimal_len
= strlen (decimal
);
584 assert (decimal_len
> 0);
587 /* Prepare number representation. */
592 /* Parse string to get maximal legal prefix. We need the number of
593 characters of the integer part, the fractional part and the exponent. */
595 /* Ignore leading white space. */
600 /* Get sign of the result. */
606 else if (c
== L_('+'))
609 /* Return 0.0 if no legal string is found.
610 No character is used even if a sign was found. */
612 if (c
== (wint_t) decimal
613 && (wint_t) cp
[1] >= L
'0' && (wint_t) cp
[1] <= L
'9')
615 /* We accept it. This funny construct is here only to indent
616 the code correctly. */
619 for (cnt
= 0; decimal
[cnt
] != '\0'; ++cnt
)
620 if (cp
[cnt
] != decimal
[cnt
])
622 if (decimal
[cnt
] == '\0' && cp
[cnt
] >= '0' && cp
[cnt
] <= '9')
624 /* We accept it. This funny construct is here only to indent
625 the code correctly. */
628 else if (c
< L_('0') || c
> L_('9'))
630 /* Check for `INF' or `INFINITY'. */
631 CHAR_TYPE lowc
= TOLOWER_C (c
);
633 if (lowc
== L_('i') && STRNCASECMP (cp
, L_("inf"), 3) == 0)
635 /* Return +/- infinity. */
637 *endptr
= (STRING_TYPE
*)
638 (cp
+ (STRNCASECMP (cp
+ 3, L_("inity"), 5) == 0
641 return negative
? -FLOAT_HUGE_VAL
: FLOAT_HUGE_VAL
;
644 if (lowc
== L_('n') && STRNCASECMP (cp
, L_("nan"), 3) == 0)
651 /* Match `(n-char-sequence-digit)'. */
654 const STRING_TYPE
*startp
= cp
;
657 while ((*cp
>= L_('0') && *cp
<= L_('9'))
658 || ({ CHAR_TYPE lo
= TOLOWER (*cp
);
659 lo
>= L_('a') && lo
<= L_('z'); })
663 /* The closing brace is missing. Only match the NAN
668 /* This is a system-dependent way to specify the
669 bitmask used for the NaN. We expect it to be
670 a number which is put in the mantissa of the
673 unsigned long long int mant
;
675 mant
= STRTOULL (startp
+ 1, &endp
, 0);
677 SET_MANTISSA (retval
, mant
);
679 /* Consume the closing brace. */
685 *endptr
= (STRING_TYPE
*) cp
;
690 /* It is really a text we do not recognize. */
694 /* First look whether we are faced with a hexadecimal number. */
695 if (c
== L_('0') && TOLOWER (cp
[1]) == L_('x'))
697 /* Okay, it is a hexa-decimal number. Remember this and skip
698 the characters. BTW: hexadecimal numbers must not be
706 /* Record the start of the digits, in case we will check their grouping. */
707 start_of_digits
= startp
= cp
;
709 /* Ignore leading zeroes. This helps us to avoid useless computations. */
711 while (c
== L
'0' || ((wint_t) thousands
!= L
'\0' && c
== (wint_t) thousands
))
714 if (__glibc_likely (thousands
== NULL
))
719 /* We also have the multibyte thousands string. */
724 for (cnt
= 0; thousands
[cnt
] != '\0'; ++cnt
)
725 if (thousands
[cnt
] != cp
[cnt
])
727 if (thousands
[cnt
] != '\0')
736 /* If no other digit but a '0' is found the result is 0.0.
737 Return current read pointer. */
738 CHAR_TYPE lowc
= TOLOWER (c
);
739 if (!((c
>= L_('0') && c
<= L_('9'))
740 || (base
== 16 && lowc
>= L_('a') && lowc
<= L_('f'))
743 c
== (wint_t) decimal
745 ({ for (cnt
= 0; decimal
[cnt
] != '\0'; ++cnt
)
746 if (decimal
[cnt
] != cp
[cnt
])
748 decimal
[cnt
] == '\0'; })
750 /* '0x.' alone is not a valid hexadecimal number.
751 '.' alone is not valid either, but that has been checked
754 || cp
!= start_of_digits
755 || (cp
[decimal_len
] >= L_('0') && cp
[decimal_len
] <= L_('9'))
756 || ({ CHAR_TYPE lo
= TOLOWER (cp
[decimal_len
]);
757 lo
>= L_('a') && lo
<= L_('f'); })))
758 || (base
== 16 && (cp
!= start_of_digits
760 || (base
!= 16 && lowc
== L_('e'))))
763 tp
= __correctly_grouped_prefixwc (start_of_digits
, cp
, thousands
,
766 tp
= __correctly_grouped_prefixmb (start_of_digits
, cp
, thousands
,
769 /* If TP is at the start of the digits, there was no correctly
770 grouped prefix of the string; so no number found. */
771 RETURN (negative
? -0.0 : 0.0,
772 tp
== start_of_digits
? (base
== 16 ? cp
- 1 : nptr
) : tp
);
775 /* Remember first significant digit and read following characters until the
776 decimal point, exponent character or any non-FP number character. */
781 if ((c
>= L_('0') && c
<= L_('9'))
783 && ({ CHAR_TYPE lo
= TOLOWER (c
);
784 lo
>= L_('a') && lo
<= L_('f'); })))
789 if (__builtin_expect ((wint_t) thousands
== L
'\0', 1)
790 || c
!= (wint_t) thousands
)
791 /* Not a digit or separator: end of the integer part. */
794 if (__glibc_likely (thousands
== NULL
))
798 for (cnt
= 0; thousands
[cnt
] != '\0'; ++cnt
)
799 if (thousands
[cnt
] != cp
[cnt
])
801 if (thousands
[cnt
] != '\0')
810 if (__builtin_expect (grouping
!= NULL
, 0) && cp
> start_of_digits
)
812 /* Check the grouping of the digits. */
814 tp
= __correctly_grouped_prefixwc (start_of_digits
, cp
, thousands
,
817 tp
= __correctly_grouped_prefixmb (start_of_digits
, cp
, thousands
,
822 /* Less than the entire string was correctly grouped. */
824 if (tp
== start_of_digits
)
825 /* No valid group of numbers at all: no valid number. */
829 /* The number is validly grouped, but consists
830 only of zeroes. The whole value is zero. */
831 RETURN (negative
? -0.0 : 0.0, tp
);
833 /* Recompute DIG_NO so we won't read more digits than
834 are properly grouped. */
837 for (tp
= startp
; tp
< cp
; ++tp
)
838 if (*tp
>= L_('0') && *tp
<= L_('9'))
848 /* We have the number of digits in the integer part. Whether these
849 are all or any is really a fractional digit will be decided
852 lead_zero
= int_no
== 0 ? (size_t) -1 : 0;
854 /* Read the fractional digits. A special case are the 'american
855 style' numbers like `16.' i.e. with decimal point but without
859 c
== (wint_t) decimal
861 ({ for (cnt
= 0; decimal
[cnt
] != '\0'; ++cnt
)
862 if (decimal
[cnt
] != cp
[cnt
])
864 decimal
[cnt
] == '\0'; })
870 while ((c
>= L_('0') && c
<= L_('9')) ||
871 (base
== 16 && ({ CHAR_TYPE lo
= TOLOWER (c
);
872 lo
>= L_('a') && lo
<= L_('f'); })))
874 if (c
!= L_('0') && lead_zero
== (size_t) -1)
875 lead_zero
= dig_no
- int_no
;
880 assert (dig_no
<= (uintmax_t) INTMAX_MAX
);
882 /* Remember start of exponent (if any). */
887 if ((base
== 16 && lowc
== L_('p'))
888 || (base
!= 16 && lowc
== L_('e')))
890 int exp_negative
= 0;
898 else if (c
== L_('+'))
901 if (c
>= L_('0') && c
<= L_('9'))
905 /* Get the exponent limit. */
910 assert (int_no
<= (uintmax_t) (INTMAX_MAX
911 + MIN_EXP
- MANT_DIG
) / 4);
912 exp_limit
= -MIN_EXP
+ MANT_DIG
+ 4 * (intmax_t) int_no
;
918 assert (lead_zero
== 0
919 && int_no
<= (uintmax_t) INTMAX_MAX
/ 4);
920 exp_limit
= MAX_EXP
- 4 * (intmax_t) int_no
+ 3;
922 else if (lead_zero
== (size_t) -1)
924 /* The number is zero and this limit is
926 exp_limit
= MAX_EXP
+ 3;
931 <= (uintmax_t) (INTMAX_MAX
- MAX_EXP
- 3) / 4);
933 + 4 * (intmax_t) lead_zero
943 <= (uintmax_t) (INTMAX_MAX
+ MIN_10_EXP
- MANT_DIG
));
944 exp_limit
= -MIN_10_EXP
+ MANT_DIG
+ (intmax_t) int_no
;
950 assert (lead_zero
== 0
951 && int_no
<= (uintmax_t) INTMAX_MAX
);
952 exp_limit
= MAX_10_EXP
- (intmax_t) int_no
+ 1;
954 else if (lead_zero
== (size_t) -1)
956 /* The number is zero and this limit is
958 exp_limit
= MAX_10_EXP
+ 1;
963 <= (uintmax_t) (INTMAX_MAX
- MAX_10_EXP
- 1));
964 exp_limit
= MAX_10_EXP
+ (intmax_t) lead_zero
+ 1;
974 if (__builtin_expect ((exponent
> exp_limit
/ 10
975 || (exponent
== exp_limit
/ 10
976 && c
- L_('0') > exp_limit
% 10)), 0))
977 /* The exponent is too large/small to represent a valid
982 /* We have to take care for special situation: a joker
983 might have written "0.0e100000" which is in fact
985 if (lead_zero
== (size_t) -1)
986 result
= negative
? -0.0 : 0.0;
989 /* Overflow or underflow. */
990 result
= (exp_negative
991 ? underflow_value (negative
)
992 : overflow_value (negative
));
995 /* Accept all following digits as part of the exponent. */
998 while (*cp
>= L_('0') && *cp
<= L_('9'));
1000 RETURN (result
, cp
);
1005 exponent
+= c
- L_('0');
1009 while (c
>= L_('0') && c
<= L_('9'));
1012 exponent
= -exponent
;
1018 /* We don't want to have to work with trailing zeroes after the radix. */
1019 if (dig_no
> int_no
)
1021 while (expp
[-1] == L_('0'))
1026 assert (dig_no
>= int_no
);
1029 if (dig_no
== int_no
&& dig_no
> 0 && exponent
< 0)
1032 while (! (base
== 16 ? ISXDIGIT (expp
[-1]) : ISDIGIT (expp
[-1])))
1035 if (expp
[-1] != L_('0'))
1041 exponent
+= base
== 16 ? 4 : 1;
1043 while (dig_no
> 0 && exponent
< 0);
1047 /* The whole string is parsed. Store the address of the next character. */
1049 *endptr
= (STRING_TYPE
*) cp
;
1052 return negative
? -0.0 : 0.0;
1056 /* Find the decimal point */
1057 #ifdef USE_WIDE_CHAR
1058 while (*startp
!= decimal
)
1063 if (*startp
== decimal
[0])
1065 for (cnt
= 1; decimal
[cnt
] != '\0'; ++cnt
)
1066 if (decimal
[cnt
] != startp
[cnt
])
1068 if (decimal
[cnt
] == '\0')
1074 startp
+= lead_zero
+ decimal_len
;
1075 assert (lead_zero
<= (base
== 16
1076 ? (uintmax_t) INTMAX_MAX
/ 4
1077 : (uintmax_t) INTMAX_MAX
));
1078 assert (lead_zero
<= (base
== 16
1079 ? ((uintmax_t) exponent
1080 - (uintmax_t) INTMAX_MIN
) / 4
1081 : ((uintmax_t) exponent
- (uintmax_t) INTMAX_MIN
)));
1082 exponent
-= base
== 16 ? 4 * (intmax_t) lead_zero
: (intmax_t) lead_zero
;
1083 dig_no
-= lead_zero
;
1086 /* If the BASE is 16 we can use a simpler algorithm. */
1089 static const int nbits
[16] = { 0, 1, 2, 2, 3, 3, 3, 3,
1090 4, 4, 4, 4, 4, 4, 4, 4 };
1091 int idx
= (MANT_DIG
- 1) / BITS_PER_MP_LIMB
;
1092 int pos
= (MANT_DIG
- 1) % BITS_PER_MP_LIMB
;
1095 while (!ISXDIGIT (*startp
))
1097 while (*startp
== L_('0'))
1099 if (ISDIGIT (*startp
))
1100 val
= *startp
++ - L_('0');
1102 val
= 10 + TOLOWER (*startp
++) - L_('a');
1104 /* We cannot have a leading zero. */
1107 if (pos
+ 1 >= 4 || pos
+ 1 >= bits
)
1109 /* We don't have to care for wrapping. This is the normal
1110 case so we add the first clause in the `if' expression as
1111 an optimization. It is a compile-time constant and so does
1112 not cost anything. */
1113 retval
[idx
] = val
<< (pos
- bits
+ 1);
1118 retval
[idx
--] = val
>> (bits
- pos
- 1);
1119 retval
[idx
] = val
<< (BITS_PER_MP_LIMB
- (bits
- pos
- 1));
1120 pos
= BITS_PER_MP_LIMB
- 1 - (bits
- pos
- 1);
1123 /* Adjust the exponent for the bits we are shifting in. */
1124 assert (int_no
<= (uintmax_t) (exponent
< 0
1125 ? (INTMAX_MAX
- bits
+ 1) / 4
1126 : (INTMAX_MAX
- exponent
- bits
+ 1) / 4));
1127 exponent
+= bits
- 1 + ((intmax_t) int_no
- 1) * 4;
1129 while (--dig_no
> 0 && idx
>= 0)
1131 if (!ISXDIGIT (*startp
))
1132 startp
+= decimal_len
;
1133 if (ISDIGIT (*startp
))
1134 val
= *startp
++ - L_('0');
1136 val
= 10 + TOLOWER (*startp
++) - L_('a');
1140 retval
[idx
] |= val
<< (pos
- 4 + 1);
1145 retval
[idx
--] |= val
>> (4 - pos
- 1);
1146 val
<<= BITS_PER_MP_LIMB
- (4 - pos
- 1);
1149 int rest_nonzero
= 0;
1150 while (--dig_no
> 0)
1152 if (*startp
!= L_('0'))
1159 return round_and_return (retval
, exponent
, negative
, val
,
1160 BITS_PER_MP_LIMB
- 1, rest_nonzero
);
1164 pos
= BITS_PER_MP_LIMB
- 1 - (4 - pos
- 1);
1168 /* We ran out of digits. */
1169 MPN_ZERO (retval
, idx
);
1171 return round_and_return (retval
, exponent
, negative
, 0, 0, 0);
1174 /* Now we have the number of digits in total and the integer digits as well
1175 as the exponent and its sign. We can decide whether the read digits are
1176 really integer digits or belong to the fractional part; i.e. we normalize
1179 intmax_t incr
= (exponent
< 0
1180 ? MAX (-(intmax_t) int_no
, exponent
)
1181 : MIN ((intmax_t) dig_no
- (intmax_t) int_no
, exponent
));
1186 if (__glibc_unlikely (exponent
> MAX_10_EXP
+ 1 - (intmax_t) int_no
))
1187 return overflow_value (negative
);
1189 /* 10^(MIN_10_EXP-1) is not normal. Thus, 10^(MIN_10_EXP-1) /
1190 2^MANT_DIG is below half the least subnormal, so anything with a
1191 base-10 exponent less than the base-10 exponent (which is
1192 MIN_10_EXP - 1 - ceil(MANT_DIG*log10(2))) of that value
1193 underflows. DIG is floor((MANT_DIG-1)log10(2)), so an exponent
1194 below MIN_10_EXP - (DIG + 3) underflows. But EXPONENT is
1195 actually an exponent multiplied only by a fractional part, not an
1196 integer part, so an exponent below MIN_10_EXP - (DIG + 2)
1198 if (__glibc_unlikely (exponent
< MIN_10_EXP
- (DIG
+ 2)))
1199 return underflow_value (negative
);
1203 /* Read the integer part as a multi-precision number to NUM. */
1204 startp
= str_to_mpn (startp
, int_no
, num
, &numsize
, &exponent
1205 #ifndef USE_WIDE_CHAR
1206 , decimal
, decimal_len
, thousands
1212 /* We now multiply the gained number by the given power of ten. */
1213 mp_limb_t
*psrc
= num
;
1214 mp_limb_t
*pdest
= den
;
1216 const struct mp_power
*ttab
= &_fpioconst_pow10
[0];
1220 if ((exponent
& expbit
) != 0)
1222 size_t size
= ttab
->arraysize
- _FPIO_CONST_OFFSET
;
1226 /* FIXME: not the whole multiplication has to be
1227 done. If we have the needed number of bits we
1228 only need the information whether more non-zero
1230 if (numsize
>= ttab
->arraysize
- _FPIO_CONST_OFFSET
)
1231 cy
= __mpn_mul (pdest
, psrc
, numsize
,
1232 &__tens
[ttab
->arrayoff
1233 + _FPIO_CONST_OFFSET
],
1236 cy
= __mpn_mul (pdest
, &__tens
[ttab
->arrayoff
1237 + _FPIO_CONST_OFFSET
],
1238 size
, psrc
, numsize
);
1242 (void) SWAP (psrc
, pdest
);
1247 while (exponent
!= 0);
1250 memcpy (num
, den
, numsize
* sizeof (mp_limb_t
));
1253 /* Determine how many bits of the result we already have. */
1254 count_leading_zeros (bits
, num
[numsize
- 1]);
1255 bits
= numsize
* BITS_PER_MP_LIMB
- bits
;
1257 /* Now we know the exponent of the number in base two.
1258 Check it against the maximum possible exponent. */
1259 if (__glibc_unlikely (bits
> MAX_EXP
))
1260 return overflow_value (negative
);
1262 /* We have already the first BITS bits of the result. Together with
1263 the information whether more non-zero bits follow this is enough
1264 to determine the result. */
1265 if (bits
> MANT_DIG
)
1268 const mp_size_t least_idx
= (bits
- MANT_DIG
) / BITS_PER_MP_LIMB
;
1269 const mp_size_t least_bit
= (bits
- MANT_DIG
) % BITS_PER_MP_LIMB
;
1270 const mp_size_t round_idx
= least_bit
== 0 ? least_idx
- 1
1272 const mp_size_t round_bit
= least_bit
== 0 ? BITS_PER_MP_LIMB
- 1
1276 memcpy (retval
, &num
[least_idx
],
1277 RETURN_LIMB_SIZE
* sizeof (mp_limb_t
));
1280 for (i
= least_idx
; i
< numsize
- 1; ++i
)
1281 retval
[i
- least_idx
] = (num
[i
] >> least_bit
)
1283 << (BITS_PER_MP_LIMB
- least_bit
));
1284 if (i
- least_idx
< RETURN_LIMB_SIZE
)
1285 retval
[RETURN_LIMB_SIZE
- 1] = num
[i
] >> least_bit
;
1288 /* Check whether any limb beside the ones in RETVAL are non-zero. */
1289 for (i
= 0; num
[i
] == 0; ++i
)
1292 return round_and_return (retval
, bits
- 1, negative
,
1293 num
[round_idx
], round_bit
,
1294 int_no
< dig_no
|| i
< round_idx
);
1297 else if (dig_no
== int_no
)
1299 const mp_size_t target_bit
= (MANT_DIG
- 1) % BITS_PER_MP_LIMB
;
1300 const mp_size_t is_bit
= (bits
- 1) % BITS_PER_MP_LIMB
;
1302 if (target_bit
== is_bit
)
1304 memcpy (&retval
[RETURN_LIMB_SIZE
- numsize
], num
,
1305 numsize
* sizeof (mp_limb_t
));
1306 /* FIXME: the following loop can be avoided if we assume a
1307 maximal MANT_DIG value. */
1308 MPN_ZERO (retval
, RETURN_LIMB_SIZE
- numsize
);
1310 else if (target_bit
> is_bit
)
1312 (void) __mpn_lshift (&retval
[RETURN_LIMB_SIZE
- numsize
],
1313 num
, numsize
, target_bit
- is_bit
);
1314 /* FIXME: the following loop can be avoided if we assume a
1315 maximal MANT_DIG value. */
1316 MPN_ZERO (retval
, RETURN_LIMB_SIZE
- numsize
);
1321 assert (numsize
< RETURN_LIMB_SIZE
);
1323 cy
= __mpn_rshift (&retval
[RETURN_LIMB_SIZE
- numsize
],
1324 num
, numsize
, is_bit
- target_bit
);
1325 retval
[RETURN_LIMB_SIZE
- numsize
- 1] = cy
;
1326 /* FIXME: the following loop can be avoided if we assume a
1327 maximal MANT_DIG value. */
1328 MPN_ZERO (retval
, RETURN_LIMB_SIZE
- numsize
- 1);
1331 return round_and_return (retval
, bits
- 1, negative
, 0, 0, 0);
1335 /* Store the bits we already have. */
1336 memcpy (retval
, num
, numsize
* sizeof (mp_limb_t
));
1337 #if RETURN_LIMB_SIZE > 1
1338 if (numsize
< RETURN_LIMB_SIZE
)
1339 # if RETURN_LIMB_SIZE == 2
1340 retval
[numsize
] = 0;
1342 MPN_ZERO (retval
+ numsize
, RETURN_LIMB_SIZE
- numsize
);
1347 /* We have to compute at least some of the fractional digits. */
1349 /* We construct a fraction and the result of the division gives us
1350 the needed digits. The denominator is 1.0 multiplied by the
1351 exponent of the lowest digit; i.e. 0.123 gives 123 / 1000 and
1352 123e-6 gives 123 / 1000000. */
1357 int need_frac_digits
;
1359 mp_limb_t
*psrc
= den
;
1360 mp_limb_t
*pdest
= num
;
1361 const struct mp_power
*ttab
= &_fpioconst_pow10
[0];
1363 assert (dig_no
> int_no
1365 && exponent
>= MIN_10_EXP
- (DIG
+ 2));
1367 /* We need to compute MANT_DIG - BITS fractional bits that lie
1368 within the mantissa of the result, the following bit for
1369 rounding, and to know whether any subsequent bit is 0.
1370 Computing a bit with value 2^-n means looking at n digits after
1371 the decimal point. */
1374 /* The bits required are those immediately after the point. */
1375 assert (int_no
> 0 && exponent
== 0);
1376 need_frac_digits
= 1 + MANT_DIG
- bits
;
1380 /* The number is in the form .123eEXPONENT. */
1381 assert (int_no
== 0 && *startp
!= L_('0'));
1382 /* The number is at least 10^(EXPONENT-1), and 10^3 <
1384 int neg_exp_2
= ((1 - exponent
) * 10) / 3 + 1;
1385 /* The number is at least 2^-NEG_EXP_2. We need up to
1386 MANT_DIG bits following that bit. */
1387 need_frac_digits
= neg_exp_2
+ MANT_DIG
;
1388 /* However, we never need bits beyond 1/4 ulp of the smallest
1389 representable value. (That 1/4 ulp bit is only needed to
1390 determine tinyness on machines where tinyness is determined
1392 if (need_frac_digits
> MANT_DIG
- MIN_EXP
+ 2)
1393 need_frac_digits
= MANT_DIG
- MIN_EXP
+ 2;
1394 /* At this point, NEED_FRAC_DIGITS is the total number of
1395 digits needed after the point, but some of those may be
1397 need_frac_digits
+= exponent
;
1398 /* Any cases underflowing enough that none of the fractional
1399 digits are needed should have been caught earlier (such
1400 cases are on the order of 10^-n or smaller where 2^-n is
1401 the least subnormal). */
1402 assert (need_frac_digits
> 0);
1405 if (need_frac_digits
> (intmax_t) dig_no
- (intmax_t) int_no
)
1406 need_frac_digits
= (intmax_t) dig_no
- (intmax_t) int_no
;
1408 if ((intmax_t) dig_no
> (intmax_t) int_no
+ need_frac_digits
)
1410 dig_no
= int_no
+ need_frac_digits
;
1416 neg_exp
= (intmax_t) dig_no
- (intmax_t) int_no
- exponent
;
1418 /* Construct the denominator. */
1423 if ((neg_exp
& expbit
) != 0)
1430 densize
= ttab
->arraysize
- _FPIO_CONST_OFFSET
;
1431 memcpy (psrc
, &__tens
[ttab
->arrayoff
+ _FPIO_CONST_OFFSET
],
1432 densize
* sizeof (mp_limb_t
));
1436 cy
= __mpn_mul (pdest
, &__tens
[ttab
->arrayoff
1437 + _FPIO_CONST_OFFSET
],
1438 ttab
->arraysize
- _FPIO_CONST_OFFSET
,
1440 densize
+= ttab
->arraysize
- _FPIO_CONST_OFFSET
;
1443 (void) SWAP (psrc
, pdest
);
1449 while (neg_exp
!= 0);
1452 memcpy (den
, num
, densize
* sizeof (mp_limb_t
));
1454 /* Read the fractional digits from the string. */
1455 (void) str_to_mpn (startp
, dig_no
- int_no
, num
, &numsize
, &exponent
1456 #ifndef USE_WIDE_CHAR
1457 , decimal
, decimal_len
, thousands
1461 /* We now have to shift both numbers so that the highest bit in the
1462 denominator is set. In the same process we copy the numerator to
1463 a high place in the array so that the division constructs the wanted
1464 digits. This is done by a "quasi fix point" number representation.
1466 num: ddddddddddd . 0000000000000000000000
1468 den: ddddddddddd n >= m
1472 count_leading_zeros (cnt
, den
[densize
- 1]);
1476 /* Don't call `mpn_shift' with a count of zero since the specification
1477 does not allow this. */
1478 (void) __mpn_lshift (den
, den
, densize
, cnt
);
1479 cy
= __mpn_lshift (num
, num
, numsize
, cnt
);
1481 num
[numsize
++] = cy
;
1484 /* Now we are ready for the division. But it is not necessary to
1485 do a full multi-precision division because we only need a small
1486 number of bits for the result. So we do not use __mpn_divmod
1487 here but instead do the division here by hand and stop whenever
1488 the needed number of bits is reached. The code itself comes
1489 from the GNU MP Library by Torbj\"orn Granlund. */
1497 mp_limb_t d
, n
, quot
;
1502 assert (numsize
== 1 && n
< d
);
1506 udiv_qrnnd (quot
, n
, n
, 0, d
);
1513 cnt = BITS_PER_MP_LIMB; \
1515 count_leading_zeros (cnt, quot); \
1517 if (BITS_PER_MP_LIMB - cnt > MANT_DIG) \
1519 used = MANT_DIG + cnt; \
1520 retval[0] = quot >> (BITS_PER_MP_LIMB - used); \
1521 bits = MANT_DIG + 1; \
1525 /* Note that we only clear the second element. */ \
1526 /* The conditional is determined at compile time. */ \
1527 if (RETURN_LIMB_SIZE > 1) \
1533 else if (bits + BITS_PER_MP_LIMB <= MANT_DIG) \
1534 __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, BITS_PER_MP_LIMB, \
1538 used = MANT_DIG - bits; \
1540 __mpn_lshift_1 (retval, RETURN_LIMB_SIZE, used, quot); \
1542 bits += BITS_PER_MP_LIMB
1546 while (bits
<= MANT_DIG
);
1548 return round_and_return (retval
, exponent
- 1, negative
,
1549 quot
, BITS_PER_MP_LIMB
- 1 - used
,
1550 more_bits
|| n
!= 0);
1554 mp_limb_t d0
, d1
, n0
, n1
;
1561 if (numsize
< densize
)
1565 /* The numerator of the number occupies fewer bits than
1566 the denominator but the one limb is bigger than the
1567 high limb of the numerator. */
1574 exponent
-= BITS_PER_MP_LIMB
;
1577 if (bits
+ BITS_PER_MP_LIMB
<= MANT_DIG
)
1578 __mpn_lshift_1 (retval
, RETURN_LIMB_SIZE
,
1579 BITS_PER_MP_LIMB
, 0);
1582 used
= MANT_DIG
- bits
;
1584 __mpn_lshift_1 (retval
, RETURN_LIMB_SIZE
, used
, 0);
1586 bits
+= BITS_PER_MP_LIMB
;
1598 while (bits
<= MANT_DIG
)
1604 /* QUOT should be either 111..111 or 111..110. We need
1605 special treatment of this rare case as normal division
1606 would give overflow. */
1607 quot
= ~(mp_limb_t
) 0;
1610 if (r
< d1
) /* Carry in the addition? */
1612 add_ssaaaa (n1
, n0
, r
- d0
, 0, 0, d0
);
1615 n1
= d0
- (d0
!= 0);
1620 udiv_qrnnd (quot
, r
, n1
, n0
, d1
);
1621 umul_ppmm (n1
, n0
, d0
, quot
);
1625 if (n1
> r
|| (n1
== r
&& n0
> 0))
1627 /* The estimated QUOT was too large. */
1630 sub_ddmmss (n1
, n0
, n1
, n0
, 0, d0
);
1632 if (r
>= d1
) /* If not carry, test QUOT again. */
1635 sub_ddmmss (n1
, n0
, r
, 0, n1
, n0
);
1641 return round_and_return (retval
, exponent
- 1, negative
,
1642 quot
, BITS_PER_MP_LIMB
- 1 - used
,
1643 more_bits
|| n1
!= 0 || n0
!= 0);
1648 mp_limb_t cy
, dX
, d1
, n0
, n1
;
1652 dX
= den
[densize
- 1];
1653 d1
= den
[densize
- 2];
1655 /* The division does not work if the upper limb of the two-limb
1656 numerator is greater than the denominator. */
1657 if (__mpn_cmp (num
, &den
[densize
- numsize
], numsize
) > 0)
1660 if (numsize
< densize
)
1662 mp_size_t empty
= densize
- numsize
;
1666 exponent
-= empty
* BITS_PER_MP_LIMB
;
1669 if (bits
+ empty
* BITS_PER_MP_LIMB
<= MANT_DIG
)
1671 /* We make a difference here because the compiler
1672 cannot optimize the `else' case that good and
1673 this reflects all currently used FLOAT types
1674 and GMP implementations. */
1675 #if RETURN_LIMB_SIZE <= 2
1676 assert (empty
== 1);
1677 __mpn_lshift_1 (retval
, RETURN_LIMB_SIZE
,
1678 BITS_PER_MP_LIMB
, 0);
1680 for (i
= RETURN_LIMB_SIZE
- 1; i
>= empty
; --i
)
1681 retval
[i
] = retval
[i
- empty
];
1688 used
= MANT_DIG
- bits
;
1689 if (used
>= BITS_PER_MP_LIMB
)
1692 (void) __mpn_lshift (&retval
[used
1693 / BITS_PER_MP_LIMB
],
1696 - used
/ BITS_PER_MP_LIMB
),
1697 used
% BITS_PER_MP_LIMB
);
1698 for (i
= used
/ BITS_PER_MP_LIMB
- 1; i
>= 0; --i
)
1702 __mpn_lshift_1 (retval
, RETURN_LIMB_SIZE
, used
, 0);
1704 bits
+= empty
* BITS_PER_MP_LIMB
;
1706 for (i
= numsize
; i
> 0; --i
)
1707 num
[i
+ empty
] = num
[i
- 1];
1708 MPN_ZERO (num
, empty
+ 1);
1713 assert (numsize
== densize
);
1714 for (i
= numsize
; i
> 0; --i
)
1715 num
[i
] = num
[i
- 1];
1722 while (bits
<= MANT_DIG
)
1725 /* This might over-estimate QUOT, but it's probably not
1726 worth the extra code here to find out. */
1727 quot
= ~(mp_limb_t
) 0;
1732 udiv_qrnnd (quot
, r
, n0
, num
[densize
- 1], dX
);
1733 umul_ppmm (n1
, n0
, d1
, quot
);
1735 while (n1
> r
|| (n1
== r
&& n0
> num
[densize
- 2]))
1739 if (r
< dX
) /* I.e. "carry in previous addition?" */
1746 /* Possible optimization: We already have (q * n0) and (1 * n1)
1747 after the calculation of QUOT. Taking advantage of this, we
1748 could make this loop make two iterations less. */
1750 cy
= __mpn_submul_1 (num
, den
, densize
+ 1, quot
);
1752 if (num
[densize
] != cy
)
1754 cy
= __mpn_add_n (num
, num
, den
, densize
);
1758 n0
= num
[densize
] = num
[densize
- 1];
1759 for (i
= densize
- 1; i
> 0; --i
)
1760 num
[i
] = num
[i
- 1];
1766 for (i
= densize
; i
>= 0 && num
[i
] == 0; --i
)
1768 return round_and_return (retval
, exponent
- 1, negative
,
1769 quot
, BITS_PER_MP_LIMB
- 1 - used
,
1770 more_bits
|| i
>= 0);
1777 #if defined _LIBC && !defined USE_WIDE_CHAR
1778 libc_hidden_def (____STRTOF_INTERNAL
)
1781 /* External user entry point. */
1784 #ifdef weak_function
1787 __STRTOF (nptr
, endptr
, loc
)
1788 const STRING_TYPE
*nptr
;
1789 STRING_TYPE
**endptr
;
1792 return ____STRTOF_INTERNAL (nptr
, endptr
, 0, loc
);
1795 libc_hidden_def (__STRTOF
)
1796 libc_hidden_ver (__STRTOF
, STRTOF
)
1798 weak_alias (__STRTOF
, STRTOF
)
1800 #ifdef LONG_DOUBLE_COMPAT
1801 # if LONG_DOUBLE_COMPAT(libc, GLIBC_2_1)
1802 # ifdef USE_WIDE_CHAR
1803 compat_symbol (libc
, __wcstod_l
, __wcstold_l
, GLIBC_2_1
);
1805 compat_symbol (libc
, __strtod_l
, __strtold_l
, GLIBC_2_1
);
1808 # if LONG_DOUBLE_COMPAT(libc, GLIBC_2_3)
1809 # ifdef USE_WIDE_CHAR
1810 compat_symbol (libc
, wcstod_l
, wcstold_l
, GLIBC_2_3
);
1812 compat_symbol (libc
, strtod_l
, strtold_l
, GLIBC_2_3
);