Fix warnings on Win64.

test/cctest/test-parsing.cc

 // Copyright 2006-2009 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "token.h"
 #include "scanner.h"
+#include "utils.h"
 
 #include "cctest.h"
 
 namespace i = ::v8::internal;
 
 TEST(KeywordMatcher) {
   struct KeywordToken {
     const char* keyword;
     i::Token::Value token;
   };
@@ skipping 11 matching lines @@
       TOKEN_LIST(IGNORE, IGNORE, FUTURE)
 #undef FUTURE
 #undef IGNORE
       NULL
   };
 
   KeywordToken key_token;
   for (int i = 0; (key_token = keywords[i]).keyword != NULL; i++) {
     i::KeywordMatcher matcher;
     const char* keyword = key_token.keyword;
-    int length = strlen(keyword);
+    int length = i::StrLength(keyword);
     for (int j = 0; j < length; j++) {
       if (key_token.token == i::Token::INSTANCEOF && j == 2) {
         // "in" is a prefix of "instanceof". It's the only keyword
         // that is a prefix of another.
         CHECK_EQ(i::Token::IN, matcher.token());
       } else {
         CHECK_EQ(i::Token::IDENTIFIER, matcher.token());
       }
       matcher.AddChar(keyword[j]);
     }
     CHECK_EQ(key_token.token, matcher.token());
     // Adding more characters will make keyword matching fail.
     matcher.AddChar('z');
     CHECK_EQ(i::Token::IDENTIFIER, matcher.token());
     // Adding a keyword later will not make it match again.
     matcher.AddChar('i');
     matcher.AddChar('f');
     CHECK_EQ(i::Token::IDENTIFIER, matcher.token());
   }
 
   // Future keywords are not recognized.
   const char* future_keyword;
   for (int i = 0; (future_keyword = future_keywords[i]) != NULL; i++) {
     i::KeywordMatcher matcher;
-    int length = strlen(future_keyword);
+    int length = i::StrLength(future_keyword);
     for (int j = 0; j < length; j++) {
       matcher.AddChar(future_keyword[j]);
     }
     CHECK_EQ(i::Token::IDENTIFIER, matcher.token());
   }
 
   // Zero isn't ignored at first.
   i::KeywordMatcher bad_start;
   bad_start.AddChar(0);
   CHECK_EQ(i::Token::IDENTIFIER, bad_start.token());
@@ skipping 18 matching lines @@
   // If we mark it as failure, continuing won't help.
   i::KeywordMatcher full_stop;
   full_stop.AddChar('i');
   CHECK_EQ(i::Token::IDENTIFIER, full_stop.token());
   full_stop.Fail();
   CHECK_EQ(i::Token::IDENTIFIER, full_stop.token());
   full_stop.AddChar('f');
   CHECK_EQ(i::Token::IDENTIFIER, full_stop.token());
 }