1 # Libchrome does not support/require dmg_fp library. Instead, use standard 2 # library. 3 4 --- a/base/strings/string_number_conversions.cc 5 +++ b/base/strings/string_number_conversions.cc 6 @@ -16,7 +16,6 @@ 7 #include "base/numerics/safe_math.h" 8 #include "base/scoped_clear_errno.h" 9 #include "base/strings/utf_string_conversions.h" 10 -#include "base/third_party/dmg_fp/dmg_fp.h" 11 12 namespace base { 13 14 @@ -361,20 +360,35 @@ string16 NumberToString16(unsigned long long value) { 15 } 16 17 std::string NumberToString(double value) { 18 - // According to g_fmt.cc, it is sufficient to declare a buffer of size 32. 19 - char buffer[32]; 20 - dmg_fp::g_fmt(buffer, value); 21 - return std::string(buffer); 22 + auto ret = std::to_string(value); 23 + // If this returned an integer, don't do anything. 24 + if (ret.find('.') == std::string::npos) { 25 + return ret; 26 + } 27 + // Otherwise, it has an annoying tendency to leave trailing zeros. 28 + size_t len = ret.size(); 29 + while (len >= 2 && ret[len - 1] == '0' && ret[len - 2] != '.') { 30 + --len; 31 + } 32 + ret.erase(len); 33 + return ret; 34 } 35 36 base::string16 NumberToString16(double value) { 37 - // According to g_fmt.cc, it is sufficient to declare a buffer of size 32. 38 - char buffer[32]; 39 - dmg_fp::g_fmt(buffer, value); 40 + auto tmp = std::to_string(value); 41 + base::string16 ret(tmp.c_str(), tmp.c_str() + tmp.length()); 42 43 - // The number will be ASCII. This creates the string using the "input 44 - // iterator" variant which promotes from 8-bit to 16-bit via "=". 45 - return base::string16(&buffer[0], &buffer[strlen(buffer)]); 46 + // If this returned an integer, don't do anything. 47 + if (ret.find('.') == std::string::npos) { 48 + return ret; 49 + } 50 + // Otherwise, it has an annoying tendency to leave trailing zeros. 51 + size_t len = ret.size(); 52 + while (len >= 2 && ret[len - 1] == '0' && ret[len - 2] != '.') { 53 + --len; 54 + } 55 + ret.erase(len); 56 + return ret; 57 } 58 59 bool StringToInt(StringPiece input, int* output) { 60 @@ -418,14 +432,10 @@ bool StringToSizeT(StringPiece16 input, size_t* output) { 61 } 62 63 bool StringToDouble(const std::string& input, double* output) { 64 - // Thread-safe? It is on at least Mac, Linux, and Windows. 65 - ScopedClearErrno clear_errno; 66 - 67 char* endptr = nullptr; 68 - *output = dmg_fp::strtod(input.c_str(), &endptr); 69 + *output = strtod(input.c_str(), &endptr); 70 71 // Cases to return false: 72 - // - If errno is ERANGE, there was an overflow or underflow. 73 // - If the input string is empty, there was nothing to parse. 74 // - If endptr does not point to the end of the string, there are either 75 // characters remaining in the string after a parsed number, or the string 76 @@ -433,10 +443,11 @@ bool StringToDouble(const std::string& input, double* output) { 77 // expected end given the string's stated length to correctly catch cases 78 // where the string contains embedded NUL characters. 79 // - If the first character is a space, there was leading whitespace 80 - return errno == 0 && 81 - !input.empty() && 82 + return !input.empty() && 83 input.c_str() + input.length() == endptr && 84 - !isspace(input[0]); 85 + !isspace(input[0]) && 86 + *output != std::numeric_limits<double>::infinity() && 87 + *output != -std::numeric_limits<double>::infinity(); 88 } 89 90 // Note: if you need to add String16ToDouble, first ask yourself if it's 91 --- a/base/strings/string_number_conversions_unittest.cc 92 +++ b/base/strings/string_number_conversions_unittest.cc 93 @@ -754,20 +754,8 @@ TEST(StringNumberConversionsTest, StringToDouble) { 94 {"9e999", HUGE_VAL, false}, 95 {"9e1999", HUGE_VAL, false}, 96 {"9e19999", HUGE_VAL, false}, 97 - {"9e99999999999999999999", HUGE_VAL, false}, 98 - {"-9e307", -9e307, true}, 99 - {"-1.7976e308", -1.7976e308, true}, 100 - {"-1.7977e308", -HUGE_VAL, false}, 101 - {"-1.797693134862315807e+308", -HUGE_VAL, true}, 102 - {"-1.797693134862315808e+308", -HUGE_VAL, false}, 103 - {"-9e308", -HUGE_VAL, false}, 104 - {"-9e309", -HUGE_VAL, false}, 105 - {"-9e999", -HUGE_VAL, false}, 106 - {"-9e1999", -HUGE_VAL, false}, 107 - {"-9e19999", -HUGE_VAL, false}, 108 - {"-9e99999999999999999999", -HUGE_VAL, false}, 109 - 110 - // Test more exponents. 111 + {"9e99999999999999999999", std::numeric_limits<double>::infinity(), false}, 112 + {"-9e99999999999999999999", -std::numeric_limits<double>::infinity(), false}, 113 {"1e-2", 0.01, true}, 114 {"42 ", 42.0, false}, 115 {" 1e-2", 0.01, false}, 116 @@ -797,7 +785,8 @@ TEST(StringNumberConversionsTest, StringToDouble) { 117 for (size_t i = 0; i < arraysize(cases); ++i) { 118 double output; 119 errno = 1; 120 - EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output)); 121 + EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output)) 122 + << "for input=" << cases[i].input << "got output=" << output; 123 if (cases[i].success) 124 EXPECT_EQ(1, errno) << i; // confirm that errno is unchanged. 125 EXPECT_DOUBLE_EQ(cases[i].output, output); 126 @@ -818,13 +807,13 @@ TEST(StringNumberConversionsTest, DoubleToString) { 127 double input; 128 const char* expected; 129 } cases[] = { 130 - {0.0, "0"}, 131 + {0.0, "0.0"}, 132 {1.25, "1.25"}, 133 - {1.33518e+012, "1.33518e+12"}, 134 - {1.33489e+012, "1.33489e+12"}, 135 - {1.33505e+012, "1.33505e+12"}, 136 - {1.33545e+009, "1335450000"}, 137 - {1.33503e+009, "1335030000"}, 138 + {1.33518e+012, "1335180000000.0"}, 139 + {1.33489e+012, "1334890000000.0"}, 140 + {1.33505e+012, "1335050000000.0"}, 141 + {1.33545e+009, "1335450000.0"}, 142 + {1.33503e+009, "1335030000.0"}, 143 }; 144 145 for (size_t i = 0; i < arraysize(cases); ++i) { 146 @@ -836,12 +825,12 @@ TEST(StringNumberConversionsTest, DoubleToString) { 147 const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'}; 148 double input = 0; 149 memcpy(&input, input_bytes, arraysize(input_bytes)); 150 - EXPECT_EQ("1335179083776", NumberToString(input)); 151 + EXPECT_EQ("1335179083776.0", NumberToString(input)); 152 const char input_bytes2[8] = 153 {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'}; 154 input = 0; 155 memcpy(&input, input_bytes2, arraysize(input_bytes2)); 156 - EXPECT_EQ("1334890332160", NumberToString(input)); 157 + EXPECT_EQ("1334890332160.0", NumberToString(input)); 158 } 159 160 TEST(StringNumberConversionsTest, HexEncode) { 161
