2019-02-13 16:19:44 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* strtof.c
|
|
|
|
*
|
2022-01-08 01:04:57 +01:00
|
|
|
* Portions Copyright (c) 2019-2022, PostgreSQL Global Development Group
|
2019-02-13 16:19:44 +01:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/port/strtof.c
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "c.h"
|
|
|
|
|
|
|
|
#include <float.h>
|
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#ifndef HAVE_STRTOF
|
|
|
|
/*
|
|
|
|
* strtof() is part of C99; this version is only for the benefit of obsolete
|
|
|
|
* platforms. As such, it is known to return incorrect values for edge cases,
|
|
|
|
* which have to be allowed for in variant files for regression test results
|
|
|
|
* for any such platform.
|
|
|
|
*/
|
|
|
|
|
|
|
|
float
|
|
|
|
strtof(const char *nptr, char **endptr)
|
|
|
|
{
|
|
|
|
int caller_errno = errno;
|
|
|
|
double dresult;
|
|
|
|
float fresult;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
dresult = strtod(nptr, endptr);
|
|
|
|
fresult = (float) dresult;
|
|
|
|
|
|
|
|
if (errno == 0)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Value might be in-range for double but not float.
|
|
|
|
*/
|
|
|
|
if (dresult != 0 && fresult == 0)
|
|
|
|
caller_errno = ERANGE; /* underflow */
|
|
|
|
if (!isinf(dresult) && isinf(fresult))
|
|
|
|
caller_errno = ERANGE; /* overflow */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
caller_errno = errno;
|
|
|
|
|
|
|
|
errno = caller_errno;
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
|
2019-02-16 02:50:16 +01:00
|
|
|
#elif HAVE_BUGGY_STRTOF
|
2019-02-13 16:19:44 +01:00
|
|
|
/*
|
|
|
|
* On Windows, there's a slightly different problem: VS2013 has a strtof()
|
|
|
|
* that returns the correct results for valid input, but may fail to report an
|
|
|
|
* error for underflow or overflow, returning 0 instead. Work around that by
|
|
|
|
* trying strtod() when strtof() returns 0.0 or [+-]Inf, and calling it an
|
|
|
|
* error if the result differs. Also, strtof() doesn't handle subnormal input
|
|
|
|
* well, so prefer to round the strtod() result in such cases. (Normally we'd
|
|
|
|
* just say "too bad" if strtof() doesn't support subnormals, but since we're
|
|
|
|
* already in here fixing stuff, we might as well do the best fix we can.)
|
2019-02-16 02:50:16 +01:00
|
|
|
*
|
|
|
|
* Cygwin has a strtof() which is literally just (float)strtod(), which means
|
|
|
|
* we can't avoid the double-rounding problem; but using this wrapper does get
|
|
|
|
* us proper over/underflow checks. (Also, if they fix their strtof(), the
|
|
|
|
* wrapper doesn't break anything.)
|
|
|
|
*
|
|
|
|
* Test results on Mingw suggest that it has the same problem, though looking
|
|
|
|
* at the code I can't figure out why.
|
2019-02-13 16:19:44 +01:00
|
|
|
*/
|
|
|
|
float
|
|
|
|
pg_strtof(const char *nptr, char **endptr)
|
|
|
|
{
|
|
|
|
int caller_errno = errno;
|
|
|
|
float fresult;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
fresult = (strtof) (nptr, endptr);
|
|
|
|
if (errno)
|
|
|
|
{
|
|
|
|
/* On error, just return the error to the caller. */
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
else if ((*endptr == nptr) || isnan(fresult) ||
|
|
|
|
((fresult >= FLT_MIN || fresult <= -FLT_MIN) && !isinf(fresult)))
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If we got nothing parseable, or if we got a non-0 non-subnormal
|
|
|
|
* finite value (or NaN) without error, then return that to the caller
|
|
|
|
* without error.
|
|
|
|
*/
|
|
|
|
errno = caller_errno;
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Try again. errno is already 0 here.
|
|
|
|
*/
|
|
|
|
double dresult = strtod(nptr, NULL);
|
2019-05-22 18:55:34 +02:00
|
|
|
|
2019-02-13 16:19:44 +01:00
|
|
|
if (errno)
|
|
|
|
{
|
|
|
|
/* On error, just return the error */
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
else if ((dresult == 0.0 && fresult == 0.0) ||
|
|
|
|
(isinf(dresult) && isinf(fresult) && (fresult == dresult)))
|
|
|
|
{
|
|
|
|
/* both values are 0 or infinities of the same sign */
|
|
|
|
errno = caller_errno;
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
else if ((dresult > 0 && dresult <= FLT_MIN && (float) dresult != 0.0) ||
|
|
|
|
(dresult < 0 && dresult >= -FLT_MIN && (float) dresult != 0.0))
|
|
|
|
{
|
|
|
|
/* subnormal but nonzero value */
|
|
|
|
errno = caller_errno;
|
|
|
|
return (float) dresult;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
errno = ERANGE;
|
|
|
|
return fresult;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|