Remove the locale parameter from the StringToDouble and

base/string_util.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 71 matching lines @@
 //  - a typedef for value_type, the target numeric type.
 //  - a static function, convert_func, which dispatches to an appropriate
 //    strtol-like function and returns type value_type.
 //  - a static function, valid_func, which validates |input| and returns a bool
 //    indicating whether it is in proper form.  This is used to check for
 //    conditions that convert_func tolerates but should result in
 //    StringToNumber returning false.  For strtol-like funtions, valid_func
 //    should check for leading whitespace.
 template<typename StringToNumberTraits>
 bool StringToNumber(const typename StringToNumberTraits::string_type& input,
-                    typename StringToNumberTraits::value_type* output,
-                    base::LocaleDependence locale_dependent) {
+                    typename StringToNumberTraits::value_type* output) {
   typedef StringToNumberTraits traits;
 
   errno = 0;  // Thread-safe?  It is on at least Mac, Linux, and Windows.
   typename traits::string_type::value_type* endptr = NULL;
   typename traits::value_type value = traits::convert_func(input.c_str(),
-      &endptr, locale_dependent == base::LOCALE_DEPENDENT);
+                                                           &endptr);
   *output = value;
 
   // 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
   //    does not begin with a parseable number.  endptr is compared to the
   //    expected end given the string's stated length to correctly catch cases
   //    where the string contains embedded NUL characters.
   //  - valid_func determines that the input is not in preferred form.
   return errno == 0 &&
          !input.empty() &&
          input.c_str() + input.length() == endptr &&
          traits::valid_func(input);
 }
 
 class StringToLongTraits {
  public:
   typedef std::string string_type;
   typedef long value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return strtol(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
 class WStringToLongTraits {
  public:
   typedef std::wstring string_type;
   typedef long value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return wcstol(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 class StringToInt64Traits {
  public:
   typedef std::string string_type;
   typedef int64 value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _strtoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
     return strtoll(str, endptr, kBase);
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
 class WStringToInt64Traits {
  public:
   typedef std::wstring string_type;
   typedef int64 value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _wcstoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
     return wcstoll(str, endptr, kBase);
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 // For the HexString variants, use the unsigned variants like strtoul for
 // convert_func so that input like "0x80000000" doesn't result in an overflow.
 
 class HexStringToLongTraits {
  public:
   typedef std::string string_type;
   typedef long value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return strtoul(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
 class HexWStringToLongTraits {
  public:
   typedef std::wstring string_type;
   typedef long value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return wcstoul(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 class StringToDoubleTraits {
  public:
   typedef std::string string_type;
   typedef double value_type;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
-    if (locale_dependent) {
-      return strtod(str, endptr);
-    } else {
-      return dmg_fp::strtod(str, endptr);
-    }
+                                        string_type::value_type** endptr) {
+    return dmg_fp::strtod(str, endptr);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
 class WStringToDoubleTraits {
  public:
   typedef std::wstring string_type;
   typedef double value_type;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
-    if (locale_dependent) {
-      return wcstod(str, endptr);
-    } else {
-      // Because dmg_fp::strtod does not like wchar_t, we convert it to ASCII.
-      // In theory, this should be safe, but it's possible that wide chars
-      // might get ignored by accident causing something to be parsed when it
-      // shouldn't.
-      std::string ascii_string = WideToASCII(std::wstring(str));
-      char* ascii_end = NULL;
-      value_type ret = dmg_fp::strtod(ascii_string.c_str(), &ascii_end);
-      if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
-        // Put endptr at end of input string, so it's not recognized as an error.
-        *endptr = const_cast<string_type::value_type*>(str) + wcslen(str);
-      }
+                                        string_type::value_type** endptr) {
+    // Because dmg_fp::strtod does not like wchar_t, we convert it to ASCII.
+    // In theory, this should be safe, but it's possible that wide chars
+    // might get ignored by accident causing something to be parsed when it
+    // shouldn't.
+    std::string ascii_string = WideToASCII(std::wstring(str));
+    char* ascii_end = NULL;
+    value_type ret = dmg_fp::strtod(ascii_string.c_str(), &ascii_end);
+    if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
+      // Put endptr at end of input string, so it's not recognized as an error.
+      *endptr = const_cast<string_type::value_type*>(str) + wcslen(str);
+    }
 
-      return ret;
-    }
+    return ret;
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 }  // namespace
 
 
 namespace base {
@@ skipping 28 matching lines @@
           in_specification = false;
         }
       }
     }
 
   }
 
   return true;
 }
 
-std::string DoubleToString(double value, LocaleDependence locale_dependent) {
-  if (LOCALE_DEPENDENT == locale_dependent) {
-    return StringPrintf("%g", value);
-  } else {
-    char buffer[32];
-    dmg_fp::g_fmt(buffer, value);
-    return std::string(buffer);
-  }
-}
-
-std::wstring DoubleToWString(double value, LocaleDependence locale_dependent) {
-  return ASCIIToWide(DoubleToString(value, locale_dependent));
-}
-
-bool StringToDouble(const std::string& input, double* output,
-                    LocaleDependence locale_dependent) {
-  return StringToNumber<StringToDoubleTraits>(input, output,
-                                              locale_dependent);
-}
-
-bool StringToDouble(const std::wstring& input, double* output,
-                    LocaleDependence locale_dependent) {
-  return StringToNumber<WStringToDoubleTraits>(input, output,
-                                               locale_dependent);
-}
-
-double StringToDouble(const std::string& value,
-                      LocaleDependence locale_dependent) {
-  double result;
-  StringToDouble(value, &result, locale_dependent);
-  return result;
-}
-
-double StringToDouble(const std::wstring& value,
-                      LocaleDependence locale_dependent) {
-  double result;
-  StringToDouble(value, &result, locale_dependent);
-  return result;
-}
 
 }  // namespace base
 
 
 const std::string& EmptyString() {
   return *Singleton<std::string>::get();
 }
 
 const std::wstring& EmptyWString() {
   return *Singleton<std::wstring>::get();
@@ skipping 690 matching lines @@
 }
 std::string Uint64ToString(uint64 value) {
   return IntToStringT<std::string, uint64, uint64, false>::
       IntToString(value);
 }
 std::wstring Uint64ToWString(uint64 value) {
   return IntToStringT<std::wstring, uint64, uint64, false>::
       IntToString(value);
 }
 
+std::string DoubleToString(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);
+}
+
+std::wstring DoubleToWString(double value) {
+  return ASCIIToWide(DoubleToString(value));
+}
+
 inline void StringAppendV(std::string* dst, const char* format, va_list ap) {
   StringAppendVT<char>(dst, format, ap);
 }
 
 inline void StringAppendV(std::wstring* dst,
                           const wchar_t* format,
                           va_list ap) {
   StringAppendVT<wchar_t>(dst, format, ap);
 }
 
-bool StringToDouble(const std::string& input, double* output) {
-  return StringToDouble(input, output, base::LOCALE_DEPENDENT);
-}
-
-bool StringToDouble(const std::wstring& input, double* output) {
-  return StringToDouble(input, output, base::LOCALE_DEPENDENT);
-}
-
-double StringToDouble(const std::string& value) {
-  return StringToDouble(value, base::LOCALE_DEPENDENT);
-}
-
-double StringToDouble(const std::wstring& value) {
-  return StringToDouble(value, base::LOCALE_DEPENDENT);
-}
-
 std::string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   std::string result;
   StringAppendV(&result, format, ap);
   va_end(ap);
   return result;
 }
 
 std::wstring StringPrintf(const wchar_t* format, ...) {
@@ skipping 319 matching lines @@
 }
 
 // For the various *ToInt conversions, there are no *ToIntTraits classes to use
 // because there's no such thing as strtoi.  Use *ToLongTraits through a cast
 // instead, requiring that long and int are compatible and equal-width.  They
 // are on our target platforms.
 
 bool StringToInt(const std::string& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_strtol_to_int);
   return StringToNumber<StringToLongTraits>(input,
-                                            reinterpret_cast<long*>(output),
-                                            base::LOCALE_DEPENDENT);
+                                            reinterpret_cast<long*>(output));
 }
 
 bool StringToInt(const std::wstring& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
   return StringToNumber<WStringToLongTraits>(input,
-                                             reinterpret_cast<long*>(output),
-                                             base::LOCALE_DEPENDENT);
+                                             reinterpret_cast<long*>(output));
 }
 
 bool StringToInt64(const std::string& input, int64* output) {
-  return StringToNumber<StringToInt64Traits>(input, output, base::LOCALE_DEPENDENT);
+  return StringToNumber<StringToInt64Traits>(input, output);
 }
 
 bool StringToInt64(const std::wstring& input, int64* output) {
-  return StringToNumber<WStringToInt64Traits>(input, output, base::LOCALE_DEPENDENT);
+  return StringToNumber<WStringToInt64Traits>(input, output);
 }
 
 bool HexStringToInt(const std::string& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_strtol_to_int);
   return StringToNumber<HexStringToLongTraits>(input,
-                                               reinterpret_cast<long*>(output),
-                                               base::LOCALE_DEPENDENT);
+                                               reinterpret_cast<long*>(output));
 }
 
 bool HexStringToInt(const std::wstring& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
   return StringToNumber<HexWStringToLongTraits>(
-      input, reinterpret_cast<long*>(output), base::LOCALE_DEPENDENT);
+      input, reinterpret_cast<long*>(output));
 }
 
 int StringToInt(const std::string& value) {
   int result;
   StringToInt(value, &result);
   return result;
 }
 
 int StringToInt(const std::wstring& value) {
   int result;
@@ skipping 18 matching lines @@
   HexStringToInt(value, &result);
   return result;
 }
 
 int HexStringToInt(const std::wstring& value) {
   int result;
   HexStringToInt(value, &result);
   return result;
 }
 
+bool StringToDouble(const std::string& input, double* output) {
+  return StringToNumber<StringToDoubleTraits>(input, output);
+}
+
+bool StringToDouble(const std::wstring& input, double* output) {
+  return StringToNumber<WStringToDoubleTraits>(input, output);
+}
+
+double StringToDouble(const std::string& value) {
+  double result;
+  StringToDouble(value, &result);
+  return result;
+}
+
+double StringToDouble(const std::wstring& value) {
+  double result;
+  StringToDouble(value, &result);
+  return result;
+}
+
 // The following code is compatible with the OpenBSD lcpy interface.  See:
 //   http://www.gratisoft.us/todd/papers/strlcpy.html
 //   ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
 
 namespace {
 
 template <typename CHAR>
 size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
   for (size_t i = 0; i < dst_size; ++i) {
     if ((dst[i] = src[i]) == 0)  // We hit and copied the terminating NULL.
@@ skipping 47 matching lines @@
       int rstr_len = (max_len - 3) / 2;
       int lstr_len = rstr_len + ((max_len - 3) % 2);
       output->assign(input.substr(0, lstr_len) + L"..." +
                      input.substr(input.length() - rstr_len));
       break;
     }
   }
 
   return true;
 }