Add 64bit support.

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 22 matching lines @@
 struct EmptyStrings {
   EmptyStrings() {}
   const std::string s;
   const std::wstring ws;
   const string16 s16;
 };
 
 // Used by ReplaceStringPlaceholders to track the position in the string of
 // replaced parameters.
 struct ReplacementOffset {
-  ReplacementOffset(int parameter, size_t offset)
+  ReplacementOffset(uintptr_t parameter, size_t offset)
       : parameter(parameter),
         offset(offset) {}
 
   // Index of the parameter.
-  int parameter;
+  uintptr_t parameter;
 
   // Starting position in the string.
   size_t offset;
 };
 
 static bool CompareParameter(const ReplacementOffset& elem1,
                              const ReplacementOffset& elem2) {
   return elem1.parameter < elem2.parameter;
 }
 
@@ skipping 574 matching lines @@
 //   the Initial Developer. All Rights Reserved.
 //
 //   Contributor(s):
 //     Scott Collins <scc@mozilla.org> (original author)
 //
 // This is a template so that it can be run on wide and 8-bit strings. We want
 // to run it on wide strings when we have input that we think may have
 // originally been UTF-8, but has been converted to wide characters because
 // that's what we (and Windows) use internally.
 template<typename CHAR>
-static bool IsStringUTF8T(const CHAR* str, int length) {
+static bool IsStringUTF8T(const CHAR* str, size_t length) {
   bool overlong = false;
   bool surrogate = false;
   bool nonchar = false;
 
   // overlong byte upper bound
   typename ToUnsigned<CHAR>::Unsigned olupper = 0;
 
   // surrogate byte lower bound
   typename ToUnsigned<CHAR>::Unsigned slower = 0;
 
   // incremented when inside a multi-byte char to indicate how many bytes
   // are left in the sequence
   int positions_left = 0;
 
-  for (int i = 0; i < length; i++) {
+  for (uintptr_t i = 0; i < length; i++) {
     // This whole function assume an unsigned value so force its conversion to
     // an unsigned value.
     typename ToUnsigned<CHAR>::Unsigned c = str[i];
     if (c < 0x80)
       continue;  // ASCII
 
     if (c <= 0xC1) {
       // [80-BF] where not expected, [C0-C1] for overlong
       return false;
     } else if (IsBegin2ByteUTF8(c)) {
@@ skipping 755 matching lines @@
 #endif
 
 void SplitStringAlongWhitespace(const std::string& str,
                                 std::vector<std::string>* result) {
   SplitStringAlongWhitespaceT(str, result);
 }
 
 template<class FormatStringType, class OutStringType>
 OutStringType DoReplaceStringPlaceholders(const FormatStringType& format_string,
     const std::vector<OutStringType>& subst, std::vector<size_t>* offsets) {
-  int substitutions = subst.size();
+  size_t substitutions = subst.size();
   DCHECK(substitutions < 10);
 
-  int sub_length = 0;
+  size_t sub_length = 0;
   for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
        iter != subst.end(); ++iter) {
     sub_length += (*iter).length();
   }
 
   OutStringType formatted;
   formatted.reserve(format_string.length() + sub_length);
 
   std::vector<ReplacementOffset> r_offsets;
   for (typename FormatStringType::const_iterator i = format_string.begin();
        i != format_string.end(); ++i) {
     if ('$' == *i) {
       if (i + 1 != format_string.end()) {
         ++i;
         DCHECK('$' == *i || '1' <= *i) << "Invalid placeholder: " << *i;
         if ('$' == *i) {
           formatted.push_back('$');
         } else {
-          int index = *i - '1';
+          uintptr_t index = *i - '1';
           if (offsets) {
             ReplacementOffset r_offset(index,
                 static_cast<int>(formatted.size()));
             r_offsets.insert(std::lower_bound(r_offsets.begin(),
                 r_offsets.end(), r_offset,
                 &CompareParameter),
                 r_offset);
           }
           if (index < substitutions)
             formatted.append(subst.at(index));
@@ skipping 182 matching lines @@
   else if (digit >= 'A' && digit <= 'F')
     *val = 10 + digit - 'A';
   else
     return false;
   return true;
 }
 
 template<typename STR>
 bool HexStringToBytesT(const STR& input, std::vector<uint8>* output) {
   DCHECK(output->size() == 0);
-  int count = input.size();
+  size_t count = input.size();
   if (count == 0 || (count % 2) != 0)
     return false;
-  for (int i = 0; i < count / 2; ++i) {
+  for (uintptr_t i = 0; i < count / 2; ++i) {
     uint8 msb = 0;  // most significant 4 bits
     uint8 lsb = 0;  // least significant 4 bits
     if (!HexDigitToIntT(input[i * 2], &msb) ||
         !HexDigitToIntT(input[i * 2 + 1], &lsb))
       return false;
     output->push_back((msb << 4) | lsb);
   }
   return true;
 }
 
@@ skipping 137 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;
 }