Add host callback for debug break....

src/debug.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 1333 matching lines @@
       0, NULL, &caught_exception);
 }
 
 
 Handle<Object> Debugger::event_listener_ = Handle<Object>();
 Handle<Object> Debugger::event_listener_data_ = Handle<Object>();
 bool Debugger::debugger_active_ = false;
 bool Debugger::compiling_natives_ = false;
 bool Debugger::is_loading_debugger_ = false;
 DebugMessageThread* Debugger::message_thread_ = NULL;
-v8::DebugMessageHandler Debugger::debug_message_handler_ = NULL;
-void* Debugger::debug_message_handler_data_ = NULL;
+v8::DebugMessageHandler Debugger::message_handler_ = NULL;
+void* Debugger::message_handler_data_ = NULL;
+v8::DebugHostDispatchHandler Debugger::host_dispatch_handler_ = NULL;
+void* Debugger::host_dispatch_handler_data_ = NULL;
 
 
 Handle<Object> Debugger::MakeJSObject(Vector<const char> constructor_name,
                                       int argc, Object*** argv,
                                       bool* caught_exception) {
   ASSERT(Top::context() == *Debug::debug_context());
 
   // Create the execution state object.
   Handle<String> constructor_str = Factory::LookupSymbol(constructor_name);
   Handle<Object> constructor(Top::global()->GetProperty(*constructor_str));
@@ skipping 336 matching lines @@
       data = Factory::undefined_value();
     }
     event_listener_data_ = Handle<Object>::cast(GlobalHandles::Create(*data));
   }
 
   UpdateActiveDebugger();
 }
 
 
 void Debugger::SetMessageHandler(v8::DebugMessageHandler handler, void* data) {
-  debug_message_handler_ = handler;
-  debug_message_handler_data_ = data;
+  message_handler_ = handler;
+  message_handler_data_ = data;
   if (!message_thread_) {
     message_thread_ = new DebugMessageThread();
     message_thread_->Start();
   }
   UpdateActiveDebugger();
 }
 
 
+void Debugger::SetHostDispatchHandler(v8::DebugHostDispatchHandler handler,
+                                      void* data) {
+  host_dispatch_handler_ = handler;
+  host_dispatch_handler_data_ = data;
+}
+
+
 // Posts an output message from the debugger to the debug_message_handler
 // callback.  This callback is part of the public API.  Messages are
 // kept internally as Vector<uint16_t> strings, which are allocated in various
 // places and deallocated by the calling function sometime after this call.
 void Debugger::SendMessage(Vector< uint16_t> message) {
-  if (debug_message_handler_ != NULL) {
-    debug_message_handler_(message.start(), message.length(),
-                           debug_message_handler_data_);
+  if (message_handler_ != NULL) {
+    message_handler_(message.start(), message.length(), message_handler_data_);
   }
 }
 
 
 void Debugger::ProcessCommand(Vector<const uint16_t> command) {
   if (message_thread_ != NULL) {
     message_thread_->ProcessCommand(
         Vector<uint16_t>(const_cast<uint16_t *>(command.start()),
                          command.length()));
   }
 }
 
 
+void Debugger::ProcessHostDispatch(void* dispatch) {
+  if (message_thread_ != NULL) {
+    message_thread_->ProcessHostDispatch(dispatch);
+  }
+}
+
+
 void Debugger::UpdateActiveDebugger() {
   set_debugger_active((message_thread_ != NULL &&
-                       debug_message_handler_ != NULL) ||
+                       message_handler_ != NULL) ||
                        !event_listener_.is_null());
   if (!debugger_active() && message_thread_) {
     message_thread_->OnDebuggerInactive();
   }
   if (!debugger_active()) {
     Debug::Unload();
   }
 }
 
 
@@ skipping 151 matching lines @@
   while (true) {
     command_received_->Wait();
     Logger::DebugTag("Got request from command queue, in interactive loop.");
     Vector<uint16_t> command = command_queue_.Get();
     ASSERT(!host_running_);
     if (!Debugger::debugger_active()) {
       host_running_ = true;
       return;
     }
 
+    // Check if the command is a host dispatch.
+    if (command[0] == 0) {
+      if (Debugger::host_dispatch_handler_) {
+        int32_t dispatch = (command[1] << 16) | command[2];
+        Debugger::host_dispatch_handler_(reinterpret_cast<void*>(dispatch),

[yurys, 2009/02/19 14:44:18]

why not just call dispatch with some dispatch data without this indirection?

+                                         Debugger::host_dispatch_handler_data_);
+      }
+      continue;
+    }
+
     // Invoke the JavaScript to process the debug request.
     v8::Local<v8::String> fun_name;
     v8::Local<v8::Function> fun;
     v8::Local<v8::Value> request;
     v8::TryCatch try_catch;
     fun_name = v8::String::New("processDebugRequest");
     fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
     request = v8::String::New(reinterpret_cast<uint16_t*>(command.start()),
                               command.length());
     static const int kArgc = 1;
@@ skipping 57 matching lines @@
 // processing of the command to the DebugMessageThread thread.
 // The new copy of the command is destroyed in HandleCommand().
 void DebugMessageThread::ProcessCommand(Vector<uint16_t> command) {
   Vector<uint16_t> command_copy = command.Clone();
   Logger::DebugTag("Put command on command_queue.");
   command_queue_.Put(command_copy);
   command_received_->Signal();
 }
 
 
+// Puts a host dispatch comming from the public API on the queue.
+void DebugMessageThread::ProcessHostDispatch(void* dispatch) {
+  uint16_t hack[3];
+  hack[0] = 0;
+  hack[1] = reinterpret_cast<uint32_t>(dispatch) >> 16;
+  hack[2] = reinterpret_cast<uint32_t>(dispatch) & 0xFFFF;
+  Logger::DebugTag("Put dispatch on command_queue.");
+  command_queue_.Put(Vector<uint16_t>(hack, 3).Clone());
+  command_received_->Signal();
+}
+
+
 void DebugMessageThread::OnDebuggerInactive() {
   // Send an empty command to the debugger if in a break to make JavaScript run
   // again if the debugger is closed.
   if (!host_running_) {
     ProcessCommand(Vector<uint16_t>::empty());
   }
 }
 
 
 MessageQueue::MessageQueue(int size) : start_(0), end_(0), size_(size) {
@@ skipping 66 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal