Periodic merge of bleeding_edge to experimental code generator branch....

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 1632 matching lines @@
     active_listener = !listeners.get(i)->IsUndefined();
   }
   set_debugger_active((Debugger::message_thread_ != NULL &&
                        Debugger::debug_message_handler_ != NULL) ||
                        active_listener);
   if (!debugger_active() && message_thread_)
     message_thread_->OnDebuggerInactive();
 }
 
 
+Handle<Object> Debugger::Call(Handle<JSFunction> fun,
+                              Handle<Object> data,
+                              bool* pending_exception) {
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter() || !debugger.HasJavaScriptFrames()) {
+    return Factory::undefined_value();
+  }
+
+  // Create the execution state.
+  bool caught_exception = false;
+  Handle<Object> exec_state = MakeExecutionState(&caught_exception);
+  if (caught_exception) {
+    return Factory::undefined_value();
+  }
+
+  static const int kArgc = 2;
+  Object** argv[kArgc] = { exec_state.location(), data.location() };
+  Handle<Object> result = Execution::Call(fun, Factory::undefined_value(),
+                                          kArgc, argv, pending_exception);
+  return result;
+}
+
+
 DebugMessageThread::DebugMessageThread()
     : host_running_(true),
       command_queue_(kQueueInitialSize),
       message_queue_(kQueueInitialSize) {
   command_received_ = OS::CreateSemaphore(0);
   message_received_ = OS::CreateSemaphore(0);
 }
 
 // Does not free resources held by DebugMessageThread
 // because this cannot be done thread-safely.
@@ skipping 99 matching lines @@
       v8::Object::Cast(*fun->Call(api_exec_state, 0, NULL));
   if (try_catch.HasCaught()) {
     PrintLn(try_catch.Exception());
     return;
   }
 
   // Notify the debugger that a debug event has occurred.
   host_running_ = false;
   SetEventJSONFromEvent(event_data);
 
-  // Wait for commands from the debugger.
+  // Wait for requests from the debugger.
   while (true) {
     command_received_->Wait();
-    Logger::DebugTag("Get command from command queue, in interactive loop.");
+    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;
     }
 
-    // Invoke the JavaScript to convert the debug command line to a JSON
-    // request, invoke the JSON request and convert the JSON response to a text
-    // representation.
+    // Invoke the JavaScript to process the debug request.
     v8::Local<v8::String> fun_name;
     v8::Local<v8::Function> fun;
-    v8::Local<v8::Value> args[1];
+    v8::Local<v8::Value> request;
     v8::TryCatch try_catch;
-    fun_name = v8::String::New("processDebugCommand");
+    fun_name = v8::String::New("processDebugRequest");
     fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
-    args[0] = v8::String::New(reinterpret_cast<uint16_t*>(command.start()),
+    request = v8::String::New(reinterpret_cast<uint16_t*>(command.start()),
                               command.length());
-    v8::Local<v8::Value> result_val = fun->Call(cmd_processor, 1, args);
+    static const int kArgc = 1;
+    v8::Handle<Value> argv[kArgc] = { request };
+    v8::Local<v8::Value> response_val = fun->Call(cmd_processor, kArgc, argv);
 
-    // Get the result of the command.
-    v8::Local<v8::String> result_string;
+    // Get the response.
+    v8::Local<v8::String> response;
     bool running = false;
     if (!try_catch.HasCaught()) {
-      // Get the result as an object.
-      v8::Local<v8::Object> result = v8::Object::Cast(*result_val);
+      // Get response string.
+      if (!response_val->IsUndefined()) {
+        response = v8::String::Cast(*response_val);
+      } else {
+        response = v8::String::New("");
+      }
 
       // Log the JSON request/response.
       if (FLAG_trace_debug_json) {
-        PrintLn(result->Get(v8::String::New("request")));
-        PrintLn(result->Get(v8::String::New("response")));
+        PrintLn(request);
+        PrintLn(response);
       }
 
       // Get the running state.
-      running = result->Get(v8::String::New("running"))->ToBoolean()->Value();
-
-      // Get result text.
-      v8::Local<v8::Value> text_result =
-          result->Get(v8::String::New("response"));
-      if (!text_result->IsUndefined()) {
-        result_string = text_result->ToString();
-      } else {
-        result_string = v8::String::New("");
+      fun_name = v8::String::New("isRunning");
+      fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
+      static const int kArgc = 1;
+      v8::Handle<Value> argv[kArgc] = { response };
+      v8::Local<v8::Value> running_val = fun->Call(cmd_processor, kArgc, argv);
+      if (!try_catch.HasCaught()) {
+        running = running_val->ToBoolean()->Value();
       }
     } else {
       // In case of failure the result text is the exception text.
-      result_string = try_catch.Exception()->ToString();
+      response = try_catch.Exception()->ToString();
     }
 
     // Convert text result to C string.
-    v8::String::Value val(result_string);
+    v8::String::Value val(response);
     Vector<uint16_t> str(reinterpret_cast<uint16_t*>(*val),
-                        result_string->Length());
+                        response->Length());
 
     // Set host_running_ correctly for nested debugger evaluations.
     host_running_ = running;
 
     // Return the result.
     SendMessage(str);
 
     // Return from debug event processing is VM should be running.
     if (running) {
       return;
@@ skipping 95 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal