Fix debugging module(replace int with intptr_t) so it works on Windows x64.

runtime/bin/dbg_connection.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/dbg_connection.h"
 #include "bin/dbg_message.h"
 #include "bin/dartutils.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/json.h"
 #include "platform/thread.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 
 namespace dart {
 namespace bin {
 
 extern bool trace_debug_protocol;
 
-int DebuggerConnectionHandler::listener_fd_ = -1;
+intptr_t DebuggerConnectionHandler::listener_fd_ = -1;
 dart::Monitor* DebuggerConnectionHandler::handler_lock_ = new dart::Monitor();
 
 // TODO(asiva): Remove this once we have support for multiple debugger
 // connections. For now we just store the single debugger connection
 // handler in a static variable.
 static DebuggerConnectionHandler* singleton_handler = NULL;
 
 // The maximum message length to print when --trace_debug_protocol is
 // specified.
 static const int kMaxPrintMessageLen = 1024;
 
 class MessageBuffer {
  public:
-  explicit MessageBuffer(int fd);
+  explicit MessageBuffer(intptr_t fd);
   ~MessageBuffer();
   void ReadData();
   bool IsValidMessage() const;
   void PopMessage();
   int MessageId() const;
   char* buf() const { return buf_; }
   bool Alive() const { return connection_is_alive_; }
 
  private:
   static const int kInitialBufferSize = 256;
   char* buf_;
   int buf_length_;
-  int fd_;
+  intptr_t fd_;
   int data_length_;
   bool connection_is_alive_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageBuffer);
 };
 
 
-MessageBuffer::MessageBuffer(int fd)
+MessageBuffer::MessageBuffer(intptr_t fd)
     :  buf_(NULL),
        buf_length_(0),
        fd_(fd),
        data_length_(0),
        connection_is_alive_(true) {
   buf_ = reinterpret_cast<char*>(malloc(kInitialBufferSize));
   if (buf_ == NULL) {
     FATAL("Failed to allocate message buffer\n");
   }
   buf_length_ = kInitialBufferSize;
@@ skipping 73 matching lines @@
   }
 }
 
 
 static bool IsValidJSON(const char* msg) {
   dart::JSONReader r(msg);
   return r.CheckMessage();
 }
 
 
-DebuggerConnectionHandler::DebuggerConnectionHandler(int debug_fd)
+DebuggerConnectionHandler::DebuggerConnectionHandler(intptr_t debug_fd)
     : debug_fd_(debug_fd), msgbuf_(NULL) {
   msgbuf_ = new MessageBuffer(debug_fd_);
 }
 
 
 DebuggerConnectionHandler::~DebuggerConnectionHandler() {
   CloseDbgConnection();
   DebuggerConnectionHandler::RemoveDebuggerConnection(debug_fd_);
 }
 
@@ skipping 35 matching lines @@
       return;
     }
 
     if (trace_debug_protocol) {
       dart::JSONReader r(msgbuf_->buf());
       const char* msg_end = r.EndOfObject();
       if (msg_end != NULL) {
         intptr_t msg_len = msg_end - msgbuf_->buf();
         int print_len = ((msg_len > kMaxPrintMessageLen)
                          ? kMaxPrintMessageLen : msg_len);
-        Log::Print("[<<<] Receiving message from debug fd %d:\n%.*s%s\n",
+        Log::Print("[<<<] Receiving message from debug fd %" Pd ":\n%.*s%s\n",
                    debug_fd_, print_len, msgbuf_->buf(),
                    ((msg_len > print_len) ? "..." : ""));
       }
     }
 
     // Parse out the command portion from the message.
     dart::JSONReader r(msgbuf_->buf());
     bool found = r.Seek("command");
     if (r.Error()) {
       FATAL("Illegal JSON message received");
@@ skipping 44 matching lines @@
 
       // This is an unrecognized command, report error and move on to next.
       Log::Print("unrecognized command received: '%s'\n", msgbuf_->buf());
       HandleUnknownMsg();
       msgbuf_->PopMessage();
     }
   }
 }
 
 
-void DebuggerConnectionHandler::SendError(int debug_fd,
+void DebuggerConnectionHandler::SendError(intptr_t debug_fd,
                                           int msg_id,
                                           const char* err_msg) {
   dart::TextBuffer msg(64);
   msg.Printf("{\"id\": %d, \"error\": \"Error: ", msg_id);
   msg.AddEscapedString(err_msg);
   msg.Printf("\"}");
   SendMsg(debug_fd, &msg);
 }
 
 
@@ skipping 58 matching lines @@
     // connections.
     return;
   }
   while (!IsConnected()) {
     dart::Monitor::WaitResult res = ml.Wait();
     ASSERT(res == dart::Monitor::kNotified);
   }
 }
 
 
-void DebuggerConnectionHandler::SendMsg(int debug_fd, dart::TextBuffer* msg) {
+void DebuggerConnectionHandler::SendMsg(intptr_t debug_fd,
+                                        dart::TextBuffer* msg) {
   ASSERT(handler_lock_ != NULL);
   MonitorLocker ml(handler_lock_);
   SendMsgHelper(debug_fd, msg);
 }
 
 
 void DebuggerConnectionHandler::BroadcastMsg(dart::TextBuffer* msg) {
   ASSERT(handler_lock_ != NULL);
   MonitorLocker ml(handler_lock_);
   if (!IsListening()) {
     // If we are only running the vm service, don't try to broadcast
     // to debugger clients.
     return;
   }
   // TODO(asiva): Once we support connection to multiple debuggers
   // we need to send the message to all of them.
   ASSERT(singleton_handler != NULL);
   SendMsgHelper(singleton_handler->debug_fd(), msg);
 }
 
 
-void DebuggerConnectionHandler::SendMsgHelper(int debug_fd,
+void DebuggerConnectionHandler::SendMsgHelper(intptr_t debug_fd,
                                               dart::TextBuffer* msg) {
   ASSERT(debug_fd >= 0);
   ASSERT(IsValidJSON(msg->buf()));
 
   if (trace_debug_protocol) {
     int print_len = ((msg->length() > kMaxPrintMessageLen)
                      ? kMaxPrintMessageLen : msg->length());
-    Log::Print("[>>>] Sending message to debug fd %d:\n%.*s%s\n",
+    Log::Print("[>>>] Sending message to debug fd %" Pd ":\n%.*s%s\n",
                debug_fd, print_len, msg->buf(),
                ((msg->length() > print_len) ? "..." : ""));
   }
 
   // Sending messages in short pieces can be used to stress test the
   // debugger front-end's message handling code.
   const bool send_in_pieces = false;
   if (send_in_pieces) {
     intptr_t remaining = msg->length();
     intptr_t sent = 0;
@@ skipping 18 matching lines @@
     return;
   }
   intptr_t bytes_written =
       DebuggerConnectionImpl::Send(debug_fd, msg->buf(), msg->length());
   ASSERT(msg->length() == bytes_written);
   // TODO(hausner): Error checking. Probably just shut down the debugger
   // session if we there is an error while writing.
 }
 
 
-void DebuggerConnectionHandler::AcceptDbgConnection(int debug_fd) {
+void DebuggerConnectionHandler::AcceptDbgConnection(intptr_t debug_fd) {
   Socket::SetNoDelay(debug_fd, true);
   AddNewDebuggerConnection(debug_fd);
   {
     ASSERT(handler_lock_ != NULL);
     MonitorLocker ml(handler_lock_);
     ml.NotifyAll();
   }
   // TODO(asiva): Once we implement support for multiple connections
   // we should have a different callback for wakeups on fds which
   // are not the listener_fd_.
@@ skipping 31 matching lines @@
   int msg_id = msg_parser.MessageId();
   ASSERT(msg_id >= 0);
   dart::TextBuffer msg(64);
   msg.Printf("{ \"id\": %d, \"result\": { \"isolateIds\": [", msg_id);
   DbgMsgQueueList::ListIsolateIds(&msg);
   msg.Printf("]}}");
   in_msg->SendReply(&msg);
 }
 
 
-void DebuggerConnectionHandler::AddNewDebuggerConnection(int debug_fd) {
+void DebuggerConnectionHandler::AddNewDebuggerConnection(intptr_t debug_fd) {
   // TODO(asiva): Support multiple debugger connections, for now we just
   // create one handler, store it in a static variable and use it.
   ASSERT(singleton_handler == NULL);
   singleton_handler = new DebuggerConnectionHandler(debug_fd);
 }
 
 
-void DebuggerConnectionHandler::RemoveDebuggerConnection(int debug_fd) {
+void DebuggerConnectionHandler::RemoveDebuggerConnection(intptr_t debug_fd) {
   // TODO(asiva): Support multiple debugger connections, for now we just
   // set the static handler back to NULL.
   ASSERT(singleton_handler != NULL);
   singleton_handler = NULL;
 }
 
 
 DebuggerConnectionHandler*
-DebuggerConnectionHandler::GetDebuggerConnectionHandler(int debug_fd) {
+DebuggerConnectionHandler::GetDebuggerConnectionHandler(intptr_t debug_fd) {
   // TODO(asiva): Support multiple debugger connections, for now we just
   // return the one static handler that was created.
   ASSERT(singleton_handler != NULL);
   return singleton_handler;
 }
 
 
 bool DebuggerConnectionHandler::IsConnected() {
   // TODO(asiva): Support multiple debugger connections.
   // Return true if a connection has been established.
   return singleton_handler != NULL;
 }
 
 }  // namespace bin
 }  // namespace dart