Rewrite StringToInt traits for dealing with non-32-bit longs.

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 76 matching lines @@
   //    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 {
+static int strtoi(const char *nptr, char **endptr, int base) {
+  long res = strtol(nptr, endptr, base);
+#if __LP64__
+  // Long is 64-bits, we have to handle under/overflow ourselves.
+  if (res > kint32max) {
+    res = kint32max;
+    errno = ERANGE;
+  } else if (res < kint32min) {
+    res = kint32min;
+    errno = ERANGE;
+  }
+#endif
+  return static_cast<int>(res);
+}
+
+static unsigned int strtoui(const char *nptr, char **endptr, int base) {
+  unsigned long res = strtoul(nptr, endptr, base);
+#if __LP64__
+  // Long is 64-bits, we have to handle under/overflow ourselves.  Test to see
+  // if the result can fit into 32-bits (as signed or unsigned).
+  if (static_cast<int>(static_cast<long>(res)) != static_cast<long>(res) &&
+      static_cast<unsigned int>(res) != res) {
+    res = kuint32max;
+    errno = ERANGE;
+  }
+#endif
+  return static_cast<unsigned int>(res);
+}
+
+class StringToIntTraits {
  public:
   typedef std::string string_type;
-  typedef long value_type;
+  typedef int value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
-    return strtol(str, endptr, kBase);
+    return strtoi(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class String16ToLongTraits {
+class String16ToIntTraits {
  public:
   typedef string16 string_type;
-  typedef long value_type;
+  typedef int value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
 #if defined(WCHAR_T_IS_UTF16)
     return wcstol(str, endptr, kBase);
 #elif defined(WCHAR_T_IS_UTF32)
     std::string ascii_string = UTF16ToASCII(string16(str));
     char* ascii_end = NULL;
-    value_type ret = strtol(ascii_string.c_str(), &ascii_end, kBase);
+    value_type ret = strtoi(ascii_string.c_str(), &ascii_end, kBase);
     if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
       *endptr =
           const_cast<string_type::value_type*>(str) + ascii_string.length();
     }
     return ret;
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
@@ skipping 38 matching lines @@
 #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 {
+class HexStringToIntTraits {
  public:
   typedef std::string string_type;
-  typedef long value_type;
+  typedef int value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
-    return strtoul(str, endptr, kBase);
+    return strtoui(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class HexString16ToLongTraits {
+class HexString16ToIntTraits {
  public:
   typedef string16 string_type;
-  typedef long value_type;
+  typedef int value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
 #if defined(WCHAR_T_IS_UTF16)
     return wcstoul(str, endptr, kBase);
 #elif defined(WCHAR_T_IS_UTF32)
     std::string ascii_string = UTF16ToASCII(string16(str));
     char* ascii_end = NULL;
-    value_type ret = strtoul(ascii_string.c_str(), &ascii_end, kBase);
+    value_type ret = strtoui(ascii_string.c_str(), &ascii_end, kBase);
     if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
       *endptr =
           const_cast<string_type::value_type*>(str) + ascii_string.length();
     }
     return ret;
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
@@ skipping 1214 matching lines @@
 }
 
 bool MatchPattern(const std::wstring& eval, const std::wstring& pattern) {
   return MatchPatternT(eval.c_str(), pattern.c_str());
 }
 
 bool MatchPattern(const std::string& eval, const std::string& pattern) {
   return MatchPatternT(eval.c_str(), pattern.c_str());
 }
 
-// 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));
+  return StringToNumber<StringToIntTraits>(input, output);
 }
 
 bool StringToInt(const string16& input, int* output) {
-  COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
-  return StringToNumber<String16ToLongTraits>(input,
-                                              reinterpret_cast<long*>(output));
+  return StringToNumber<String16ToIntTraits>(input, output);
 }
 
 bool StringToInt64(const std::string& input, int64* output) {
   return StringToNumber<StringToInt64Traits>(input, output);
 }
 
 bool StringToInt64(const string16& input, int64* output) {
   return StringToNumber<String16ToInt64Traits>(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));
+  return StringToNumber<HexStringToIntTraits>(input, output);
 }
 
 bool HexStringToInt(const string16& input, int* output) {
-  COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
-  return StringToNumber<HexString16ToLongTraits>(
-      input, reinterpret_cast<long*>(output));
+  return StringToNumber<HexString16ToIntTraits>(input, output);
 }
 
 namespace {
 
 template<class CHAR>
 bool HexDigitToIntT(const CHAR digit, uint8* val) {
   if (digit >= '0' && digit <= '9')
     *val = digit - '0';
   else if (digit >= 'a' && digit <= 'f')
     *val = 10 + digit - 'a';
@@ skipping 161 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }