# Libchrome does not support/require dmg_fp library. Instead, use standard
|
# library.
|
|
--- a/base/strings/string_number_conversions.cc
|
+++ b/base/strings/string_number_conversions.cc
|
@@ -16,7 +16,6 @@
|
#include "base/numerics/safe_math.h"
|
#include "base/scoped_clear_errno.h"
|
#include "base/strings/utf_string_conversions.h"
|
-#include "base/third_party/dmg_fp/dmg_fp.h"
|
|
namespace base {
|
|
@@ -361,20 +360,35 @@ string16 NumberToString16(unsigned long long value) {
|
}
|
|
std::string NumberToString(double value) {
|
- // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
|
- char buffer[32];
|
- dmg_fp::g_fmt(buffer, value);
|
- return std::string(buffer);
|
+ auto ret = std::to_string(value);
|
+ // If this returned an integer, don't do anything.
|
+ if (ret.find('.') == std::string::npos) {
|
+ return ret;
|
+ }
|
+ // Otherwise, it has an annoying tendency to leave trailing zeros.
|
+ size_t len = ret.size();
|
+ while (len >= 2 && ret[len - 1] == '0' && ret[len - 2] != '.') {
|
+ --len;
|
+ }
|
+ ret.erase(len);
|
+ return ret;
|
}
|
|
base::string16 NumberToString16(double value) {
|
- // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
|
- char buffer[32];
|
- dmg_fp::g_fmt(buffer, value);
|
+ auto tmp = std::to_string(value);
|
+ base::string16 ret(tmp.c_str(), tmp.c_str() + tmp.length());
|
|
- // The number will be ASCII. This creates the string using the "input
|
- // iterator" variant which promotes from 8-bit to 16-bit via "=".
|
- return base::string16(&buffer[0], &buffer[strlen(buffer)]);
|
+ // If this returned an integer, don't do anything.
|
+ if (ret.find('.') == std::string::npos) {
|
+ return ret;
|
+ }
|
+ // Otherwise, it has an annoying tendency to leave trailing zeros.
|
+ size_t len = ret.size();
|
+ while (len >= 2 && ret[len - 1] == '0' && ret[len - 2] != '.') {
|
+ --len;
|
+ }
|
+ ret.erase(len);
|
+ return ret;
|
}
|
|
bool StringToInt(StringPiece input, int* output) {
|
@@ -418,14 +432,10 @@ bool StringToSizeT(StringPiece16 input, size_t* output) {
|
}
|
|
bool StringToDouble(const std::string& input, double* output) {
|
- // Thread-safe? It is on at least Mac, Linux, and Windows.
|
- ScopedClearErrno clear_errno;
|
-
|
char* endptr = nullptr;
|
- *output = dmg_fp::strtod(input.c_str(), &endptr);
|
+ *output = strtod(input.c_str(), &endptr);
|
|
// Cases to return false:
|
- // - If errno is ERANGE, there was an overflow or underflow.
|
// - If the input string is empty, there was nothing to parse.
|
// - If endptr does not point to the end of the string, there are either
|
// characters remaining in the string after a parsed number, or the string
|
@@ -433,10 +443,11 @@ bool StringToDouble(const std::string& input, double* output) {
|
// expected end given the string's stated length to correctly catch cases
|
// where the string contains embedded NUL characters.
|
// - If the first character is a space, there was leading whitespace
|
- return errno == 0 &&
|
- !input.empty() &&
|
+ return !input.empty() &&
|
input.c_str() + input.length() == endptr &&
|
- !isspace(input[0]);
|
+ !isspace(input[0]) &&
|
+ *output != std::numeric_limits<double>::infinity() &&
|
+ *output != -std::numeric_limits<double>::infinity();
|
}
|
|
// Note: if you need to add String16ToDouble, first ask yourself if it's
|
--- a/base/strings/string_number_conversions_unittest.cc
|
+++ b/base/strings/string_number_conversions_unittest.cc
|
@@ -754,20 +754,8 @@ TEST(StringNumberConversionsTest, StringToDouble) {
|
{"9e999", HUGE_VAL, false},
|
{"9e1999", HUGE_VAL, false},
|
{"9e19999", HUGE_VAL, false},
|
- {"9e99999999999999999999", HUGE_VAL, false},
|
- {"-9e307", -9e307, true},
|
- {"-1.7976e308", -1.7976e308, true},
|
- {"-1.7977e308", -HUGE_VAL, false},
|
- {"-1.797693134862315807e+308", -HUGE_VAL, true},
|
- {"-1.797693134862315808e+308", -HUGE_VAL, false},
|
- {"-9e308", -HUGE_VAL, false},
|
- {"-9e309", -HUGE_VAL, false},
|
- {"-9e999", -HUGE_VAL, false},
|
- {"-9e1999", -HUGE_VAL, false},
|
- {"-9e19999", -HUGE_VAL, false},
|
- {"-9e99999999999999999999", -HUGE_VAL, false},
|
-
|
- // Test more exponents.
|
+ {"9e99999999999999999999", std::numeric_limits<double>::infinity(), false},
|
+ {"-9e99999999999999999999", -std::numeric_limits<double>::infinity(), false},
|
{"1e-2", 0.01, true},
|
{"42 ", 42.0, false},
|
{" 1e-2", 0.01, false},
|
@@ -797,7 +785,8 @@ TEST(StringNumberConversionsTest, StringToDouble) {
|
for (size_t i = 0; i < arraysize(cases); ++i) {
|
double output;
|
errno = 1;
|
- EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
|
+ EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output))
|
+ << "for input=" << cases[i].input << "got output=" << output;
|
if (cases[i].success)
|
EXPECT_EQ(1, errno) << i; // confirm that errno is unchanged.
|
EXPECT_DOUBLE_EQ(cases[i].output, output);
|
@@ -818,13 +807,13 @@ TEST(StringNumberConversionsTest, DoubleToString) {
|
double input;
|
const char* expected;
|
} cases[] = {
|
- {0.0, "0"},
|
+ {0.0, "0.0"},
|
{1.25, "1.25"},
|
- {1.33518e+012, "1.33518e+12"},
|
- {1.33489e+012, "1.33489e+12"},
|
- {1.33505e+012, "1.33505e+12"},
|
- {1.33545e+009, "1335450000"},
|
- {1.33503e+009, "1335030000"},
|
+ {1.33518e+012, "1335180000000.0"},
|
+ {1.33489e+012, "1334890000000.0"},
|
+ {1.33505e+012, "1335050000000.0"},
|
+ {1.33545e+009, "1335450000.0"},
|
+ {1.33503e+009, "1335030000.0"},
|
};
|
|
for (size_t i = 0; i < arraysize(cases); ++i) {
|
@@ -836,12 +825,12 @@ TEST(StringNumberConversionsTest, DoubleToString) {
|
const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
|
double input = 0;
|
memcpy(&input, input_bytes, arraysize(input_bytes));
|
- EXPECT_EQ("1335179083776", NumberToString(input));
|
+ EXPECT_EQ("1335179083776.0", NumberToString(input));
|
const char input_bytes2[8] =
|
{0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
|
input = 0;
|
memcpy(&input, input_bytes2, arraysize(input_bytes2));
|
- EXPECT_EQ("1334890332160", NumberToString(input));
|
+ EXPECT_EQ("1334890332160.0", NumberToString(input));
|
}
|
|
TEST(StringNumberConversionsTest, HexEncode) {
|
