Fix Win64 build.

src/api.cc

 // Copyright 2012 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 3994 matching lines @@
     // Copy state to stack.
     char* buffer = buffer_;
     int last_character = last_character_;
     int i = 0;
     // Do a fast loop where there is no exit capacity check.
     while (true) {
       int fast_length;
       if (capacity_ == -1) {
         fast_length = length;
       } else {
-        int remaining_capacity = capacity_ - (buffer - start_);
+        int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
         // Need enough space to write everything but one character.
         STATIC_ASSERT(Utf16::kMaxExtraUtf8BytesForOneUtf16CodeUnit == 3);
         int writable_length = (remaining_capacity - 3)/3;
         // Need to drop into slow loop.
         if (writable_length <= 0) break;
         fast_length = i + writable_length;
         if (fast_length > length) fast_length = length;
       }
       // Write the characters to the stream.
       for (; i < fast_length; i++) {
         uint16_t character = *chars++;
         buffer += Utf8::Encode(buffer, character, last_character);
         last_character = character;
         ASSERT(capacity_ == -1 || (buffer - start_) <= capacity_);
       }
       // Array is fully written. Exit.
       if (fast_length == length) {
         // Write state back out to object.
         last_character_ = last_character;
         buffer_ = buffer;
         utf16_chars_read_ += i;
         return;
       }
     }
     ASSERT(capacity_ != -1);
     // Slow loop. Must check capacity on each iteration.
-    int remaining_capacity = capacity_ - (buffer - start_);
+    int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
     ASSERT(remaining_capacity >= 0);
     for (; i < length && remaining_capacity > 0; i++) {
       uint16_t character = *chars++;
       int written = WriteEndCharacter(character,
                                       last_character,
                                       remaining_capacity,
                                       buffer);
       if (written == 0) {
         early_termination_ = true;
         break;
@@ skipping 24 matching lines @@
     // Write out number of utf16 characters written to the stream.
     if (utf16_chars_read_out != NULL) {
       *utf16_chars_read_out = utf16_chars_read_;
     }
     // Only null terminate if all of the string was written and there's space.
     if (write_null &&
         !early_termination_ &&
         (capacity_ == -1 || (buffer_ - start_) < capacity_)) {
       *buffer_++ = '\0';
     }
-    return buffer_ - start_;
+    return static_cast<int>(buffer_ - start_);
   }
 
  private:
   bool early_termination_;
   int last_character_;
   char* buffer_;
   char* const start_;
   int capacity_;
   int utf16_chars_read_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8WriterVisitor);
@@ skipping 2635 matching lines @@
 
   v->VisitPointers(blocks_.first(), first_block_limit_);
 
   for (int i = 1; i < blocks_.length(); i++) {
     v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]);
   }
 }
 
 
 } }  // namespace v8::internal