Fix warnings on Win64.

src/conversions.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 32 matching lines @@
     return c - 'a' + 10;
   if ('A' <= c && c <= 'F')
     return c - 'A' + 10;
   return -1;
 }
 
 
 // Provide a common interface to getting a character at a certain
 // index from a char* or a String object.
 static inline int GetChar(const char* str, int index) {
-  ASSERT(index >= 0 && index < static_cast<int>(strlen(str)));
+  ASSERT(index >= 0 && index < StrLength(str));
   return str[index];
 }
 
 
 static inline int GetChar(String* str, int index) {
   return str->Get(index);
 }
 
 
 static inline int GetLength(const char* str) {
-  return strlen(str);
+  return StrLength(str);
 }
 
 
 static inline int GetLength(String* str) {
   return str->length();
 }
 
 
 static inline const char* GetCString(const char* str, int index) {
   return str + index;
@@ skipping 19 matching lines @@
 static inline void ReleaseCString(const char* original, const char* str) {
 }
 
 
 static inline void ReleaseCString(String* original, const char* str) {
   DeleteArray(const_cast<char *>(str));
 }
 
 
 static inline bool IsSpace(const char* str, int index) {
-  ASSERT(index >= 0 && index < static_cast<int>(strlen(str)));
+  ASSERT(index >= 0 && index < StrLength(str));
   return Scanner::kIsWhiteSpace.get(str[index]);
 }
 
 
 static inline bool IsSpace(String* str, int index) {
   return Scanner::kIsWhiteSpace.get(str->Get(index));
 }
 
 
 static inline bool SubStringEquals(const char* str,
                                    int index,
                                    const char* other) {
   return strncmp(str + index, other, strlen(other)) != 0;
 }
 
 
 static inline bool SubStringEquals(String* str, int index, const char* other) {
   HandleScope scope;
   int str_length = str->length();
-  int other_length = strlen(other);
+  int other_length = StrLength(other);
   int end = index + other_length < str_length ?
             index + other_length :
             str_length;
   Handle<String> substring =
       Factory::NewSubString(Handle<String>(str), index, end);
   return substring->IsEqualTo(Vector<const char>(other, other_length));
 }
 
 
 // Check if a string should be parsed as an octal number.  The string
@@ skipping 177 matching lines @@
     index = StringToInt(str, index, 8, &result);
   } else {
     const char* cstr = GetCString(str, index);
     const char* end;
     // Optimistically parse the number and then, if that fails,
     // check if it might have been {+,-,}Infinity.
     result = gay_strtod(cstr, &end);
     ReleaseCString(str, cstr);
     if (result != 0.0 || end != cstr) {
       // It appears that strtod worked
-      index += end - cstr;
+      index += static_cast<int>(end - cstr);
     } else {
       // Check for {+,-,}Infinity
       bool is_negative = (GetChar(str, index) == '-');
       if (GetChar(str, index) == '+' || GetChar(str, index) == '-')
         index++;
       if (!SubStringEquals(str, index, "Infinity"))
         return JUNK_STRING_VALUE;
       result = is_negative ? -V8_INFINITY : V8_INFINITY;
       index += 8;
     }
@@ skipping 43 matching lines @@
 
     case FP_ZERO:
       builder.AddCharacter('0');
       break;
 
     default: {
       int decimal_point;
       int sign;
 
       char* decimal_rep = dtoa(v, 0, 0, &decimal_point, &sign, NULL);
-      int length = strlen(decimal_rep);
+      int length = StrLength(decimal_rep);
 
       if (sign) builder.AddCharacter('-');
 
       if (length <= decimal_point && decimal_point <= 21) {
         // ECMA-262 section 9.8.1 step 6.
         builder.AddString(decimal_rep);
         builder.AddPadding('0', decimal_point - length);
 
       } else if (0 < decimal_point && decimal_point <= 21) {
         // ECMA-262 section 9.8.1 step 7.
@@ skipping 61 matching lines @@
   if (abs_value >= 1e21) {
     char arr[100];
     Vector<char> buffer(arr, ARRAY_SIZE(arr));
     return StrDup(DoubleToCString(value, buffer));
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   char* decimal_rep = dtoa(abs_value, 3, f, &decimal_point, &sign, NULL);
-  int decimal_rep_length = strlen(decimal_rep);
+  int decimal_rep_length = StrLength(decimal_rep);
 
   // Create a representation that is padded with zeros if needed.
   int zero_prefix_length = 0;
   int zero_postfix_length = 0;
 
   if (decimal_point <= 0) {
     zero_prefix_length = -decimal_point + 1;
     decimal_point = 1;
   }
 
@@ skipping 40 matching lines @@
   // letter 'e', a minus or a plus depending on the exponent, and a
   // three digit exponent.
   unsigned result_size = significant_digits + 7;
   StringBuilder builder(result_size + 1);
 
   if (negative) builder.AddCharacter('-');
   builder.AddCharacter(decimal_rep[0]);
   if (significant_digits != 1) {
     builder.AddCharacter('.');
     builder.AddString(decimal_rep + 1);
-    builder.AddPadding('0', significant_digits - strlen(decimal_rep));
+    int rep_length = StrLength(decimal_rep);
+    builder.AddPadding('0', significant_digits - rep_length);
   }
 
   builder.AddCharacter('e');
   builder.AddCharacter(negative_exponent ? '-' : '+');
   builder.AddFormatted("%d", exponent);
   return builder.Finalize();
 }
 
 
 
 char* DoubleToExponentialCString(double value, int f) {
   // f might be -1 to signal that f was undefined in JavaScript.
   ASSERT(f >= -1 && f <= 20);
 
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   char* decimal_rep = NULL;
   if (f == -1) {
     decimal_rep = dtoa(value, 0, 0, &decimal_point, &sign, NULL);
-    f = strlen(decimal_rep) - 1;
+    f = StrLength(decimal_rep) - 1;
   } else {
     decimal_rep = dtoa(value, 2, f + 1, &decimal_point, &sign, NULL);
   }
-  int decimal_rep_length = strlen(decimal_rep);
+  int decimal_rep_length = StrLength(decimal_rep);
   ASSERT(decimal_rep_length > 0);
   ASSERT(decimal_rep_length <= f + 1);
   USE(decimal_rep_length);
 
   int exponent = decimal_point - 1;
   char* result =
       CreateExponentialRepresentation(decimal_rep, exponent, negative, f+1);
 
   freedtoa(decimal_rep);
 
   return result;
 }
 
 
 char* DoubleToPrecisionCString(double value, int p) {
   ASSERT(p >= 1 && p <= 21);
 
   bool negative = false;
   if (value < 0) {
     value = -value;
     negative = true;
   }
 
   // Find a sufficiently precise decimal representation of n.
   int decimal_point;
   int sign;
   char* decimal_rep = dtoa(value, 2, p, &decimal_point, &sign, NULL);
-  int decimal_rep_length = strlen(decimal_rep);
+  int decimal_rep_length = StrLength(decimal_rep);
   ASSERT(decimal_rep_length <= p);
 
   int exponent = decimal_point - 1;
 
   char* result = NULL;
 
   if (exponent < -6 || exponent >= p) {
     result =
         CreateExponentialRepresentation(decimal_rep, exponent, negative, p);
   } else {
@@ skipping 13 matching lines @@
       builder.AddString(decimal_rep);
       builder.AddPadding('0', p - decimal_rep_length);
     } else {
       const int m = Min(decimal_rep_length, decimal_point);
       builder.AddSubstring(decimal_rep, m);
       builder.AddPadding('0', decimal_point - decimal_rep_length);
       if (decimal_point < p) {
         builder.AddCharacter('.');
         const int extra = negative ? 2 : 1;
         if (decimal_rep_length > decimal_point) {
-          const int len = strlen(decimal_rep + decimal_point);
+          const int len = StrLength(decimal_rep + decimal_point);
           const int n = Min(len, p - (builder.position() - extra));
           builder.AddSubstring(decimal_rep + decimal_point, n);
         }
         builder.AddPadding('0', extra + (p - builder.position()));
       }
     }
     result = builder.Finalize();
   }
 
   freedtoa(decimal_rep);
@@ skipping 66 matching lines @@
   // Allocate result and fill in the parts.
   StringBuilder builder(result_size + 1);
   builder.AddSubstring(integer_buffer + integer_pos + 1, integer_part_size);
   if (decimal_pos > 0) builder.AddCharacter('.');
   builder.AddSubstring(decimal_buffer, decimal_pos);
   return builder.Finalize();
 }
 
 
 } }  // namespace v8::internal