0,0 → 1,232 |
/* |
FUNCTION |
<<wcstod>>, <<wcstof>>---wide char string to double or float |
|
INDEX |
wcstod |
INDEX |
_wcstod_r |
INDEX |
wcstof |
INDEX |
_wcstof_r |
|
ANSI_SYNOPSIS |
#include <stdlib.h> |
double wcstod(const wchar_t *__restrict <[str]>, |
wchar_t **__restrict <[tail]>); |
float wcstof(const wchar_t *__restrict <[str]>, |
wchar_t **__restrict <[tail]>); |
|
double _wcstod_r(void *<[reent]>, |
const wchar_t *<[str]>, wchar_t **<[tail]>); |
float _wcstof_r(void *<[reent]>, |
const wchar_t *<[str]>, wchar_t **<[tail]>); |
|
TRAD_SYNOPSIS |
#include <stdlib.h> |
double wcstod(<[str]>,<[tail]>) |
wchar_t *__restrict <[str]>; |
wchar_t **__restrict <[tail]>; |
|
float wcstof(<[str]>,<[tail]>) |
wchar_t *__restrict <[str]>; |
wchar_t **__restrict <[tail]>; |
|
double _wcstod_r(<[reent]>,<[str]>,<[tail]>) |
wchar_t *<[reent]>; |
wchar_t *<[str]>; |
wchar_t **<[tail]>; |
|
float _wcstof_r(<[reent]>,<[str]>,<[tail]>) |
wchar_t *<[reent]>; |
wchar_t *<[str]>; |
wchar_t **<[tail]>; |
|
DESCRIPTION |
The function <<wcstod>> parses the wide character string <[str]>, |
producing a substring which can be converted to a double |
value. The substring converted is the longest initial |
subsequence of <[str]>, beginning with the first |
non-whitespace character, that has one of these formats: |
.[+|-]<[digits]>[.[<[digits]>]][(e|E)[+|-]<[digits]>] |
.[+|-].<[digits]>[(e|E)[+|-]<[digits]>] |
.[+|-](i|I)(n|N)(f|F)[(i|I)(n|N)(i|I)(t|T)(y|Y)] |
.[+|-](n|N)(a|A)(n|N)[<(>[<[hexdigits]>]<)>] |
.[+|-]0(x|X)<[hexdigits]>[.[<[hexdigits]>]][(p|P)[+|-]<[digits]>] |
.[+|-]0(x|X).<[hexdigits]>[(p|P)[+|-]<[digits]>] |
The substring contains no characters if <[str]> is empty, consists |
entirely of whitespace, or if the first non-whitespace |
character is something other than <<+>>, <<->>, <<.>>, or a |
digit, and cannot be parsed as infinity or NaN. If the platform |
does not support NaN, then NaN is treated as an empty substring. |
If the substring is empty, no conversion is done, and |
the value of <[str]> is stored in <<*<[tail]>>>. Otherwise, |
the substring is converted, and a pointer to the final string |
(which will contain at least the terminating null character of |
<[str]>) is stored in <<*<[tail]>>>. If you want no |
assignment to <<*<[tail]>>>, pass a null pointer as <[tail]>. |
<<wcstof>> is identical to <<wcstod>> except for its return type. |
|
This implementation returns the nearest machine number to the |
input decimal string. Ties are broken by using the IEEE |
round-even rule. However, <<wcstof>> is currently subject to |
double rounding errors. |
|
The alternate functions <<_wcstod_r>> and <<_wcstof_r>> are |
reentrant versions of <<wcstod>> and <<wcstof>>, respectively. |
The extra argument <[reent]> is a pointer to a reentrancy structure. |
|
RETURNS |
Return the converted substring value, if any. If |
no conversion could be performed, 0 is returned. If the |
correct value is out of the range of representable values, |
plus or minus <<HUGE_VAL>> is returned, and <<ERANGE>> is |
stored in errno. If the correct value would cause underflow, 0 |
is returned and <<ERANGE>> is stored in errno. |
|
Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>, |
<<lseek>>, <<read>>, <<sbrk>>, <<write>>. |
*/ |
|
/*- |
* Copyright (c) 2002 Tim J. Robbins |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* 1. Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* 2. Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
* SUCH DAMAGE. |
*/ |
|
#include <_ansi.h> |
#include <errno.h> |
#include <stdlib.h> |
#include <string.h> |
#include <wchar.h> |
#include <wctype.h> |
#include <locale.h> |
#include <math.h> |
|
double |
_DEFUN (_wcstod_r, (ptr, nptr, endptr), |
struct _reent *ptr _AND |
_CONST wchar_t *nptr _AND |
wchar_t **endptr) |
{ |
static const mbstate_t initial; |
mbstate_t mbs; |
double val; |
char *buf, *end; |
const wchar_t *wcp; |
size_t len; |
|
while (iswspace(*nptr)) |
nptr++; |
|
/* |
* Convert the supplied numeric wide char. string to multibyte. |
* |
* We could attempt to find the end of the numeric portion of the |
* wide char. string to avoid converting unneeded characters but |
* choose not to bother; optimising the uncommon case where |
* the input string contains a lot of text after the number |
* duplicates a lot of strtod()'s functionality and slows down the |
* most common cases. |
*/ |
wcp = nptr; |
mbs = initial; |
if ((len = _wcsrtombs_r(ptr, NULL, &wcp, 0, &mbs)) == (size_t)-1) { |
if (endptr != NULL) |
*endptr = (wchar_t *)nptr; |
return (0.0); |
} |
if ((buf = _malloc_r(ptr, len + 1)) == NULL) |
return (0.0); |
mbs = initial; |
_wcsrtombs_r(ptr, buf, &wcp, len + 1, &mbs); |
|
/* Let strtod() do most of the work for us. */ |
val = _strtod_r(ptr, buf, &end); |
|
/* |
* We only know where the number ended in the _multibyte_ |
* representation of the string. If the caller wants to know |
* where it ended, count multibyte characters to find the |
* corresponding position in the wide char string. |
*/ |
if (endptr != NULL) { |
/* The only valid multibyte char in a float converted by |
strtod/wcstod is the radix char. What we do here is, |
figure out if the radix char was in the valid leading |
float sequence in the incoming string. If so, the |
multibyte float string is strlen(radix char) - 1 bytes |
longer than the incoming wide char string has characters. |
To fix endptr, reposition end as if the radix char was |
just one byte long. The resulting difference (end - buf) |
is then equivalent to the number of valid wide characters |
in the input string. */ |
len = strlen (_localeconv_r (ptr)->decimal_point); |
if (len > 1) { |
char *d = strstr (buf, |
_localeconv_r (ptr)->decimal_point); |
if (d && d < end) |
end -= len - 1; |
} |
*endptr = (wchar_t *)nptr + (end - buf); |
} |
|
_free_r(ptr, buf); |
|
return (val); |
} |
|
float |
_DEFUN (_wcstof_r, (ptr, nptr, endptr), |
struct _reent *ptr _AND |
_CONST wchar_t *nptr _AND |
wchar_t **endptr) |
{ |
double retval = _wcstod_r (ptr, nptr, endptr); |
if (isnan (retval)) |
return nanf (NULL); |
return (float)retval; |
} |
|
#ifndef _REENT_ONLY |
|
double |
_DEFUN (wcstod, (nptr, endptr), |
_CONST wchar_t *__restrict nptr _AND wchar_t **__restrict endptr) |
{ |
return _wcstod_r (_REENT, nptr, endptr); |
} |
|
float |
_DEFUN (wcstof, (nptr, endptr), |
_CONST wchar_t *__restrict nptr _AND |
wchar_t **__restrict endptr) |
{ |
double retval = _wcstod_r (_REENT, nptr, endptr); |
if (isnan (retval)) |
return nanf (NULL); |
return (float)retval; |
} |
|
#endif |