Support afterCompile event

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 1594 matching lines @@
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeCompileEvent(script, true, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
   // Process debug event
-  ProcessDebugEvent(v8::BeforeCompile, event_data, false);
+  ProcessDebugEvent(v8::BeforeCompile, event_data, true);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script, Handle<JSFunction> fun) {
   HandleScope scope;
 
   // No compile events while compiling natives.
   if (compiling_natives()) return;
 
@@ skipping 40 matching lines @@
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
                                                false,
                                                &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event
-  ProcessDebugEvent(v8::AfterCompile, event_data, false);
+  ProcessDebugEvent(v8::AfterCompile, event_data, true);
 }
 
 
 void Debugger::OnNewFunction(Handle<JSFunction> function) {
   return;
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!Debugger::EventActive(v8::NewFunction)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeNewFunctionEvent(function, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event.
-  ProcessDebugEvent(v8::NewFunction, event_data, false);
+  ProcessDebugEvent(v8::NewFunction, event_data, true);
 }
 
 
 void Debugger::ProcessDebugEvent(v8::DebugEvent event,
                                  Handle<Object> event_data,
                                  bool auto_continue) {
   HandleScope scope;
 
   // Create the execution state.
   bool caught_exception = false;
@@ skipping 57 matching lines @@
 
 void Debugger::NotifyMessageHandler(v8::DebugEvent event,
                                     Handle<Object> exec_state,
                                     Handle<Object> event_data,
                                     bool auto_continue) {
   HandleScope scope;
 
   if (!Debug::Load()) return;
 
   // Process the individual events.
-  bool interactive = false;
+  bool sendEventMessage = false;
   switch (event) {
     case v8::Break:
-      interactive = true;  // Break event is always interactive
+      sendEventMessage = !auto_continue;
       break;
     case v8::Exception:
-      interactive = true;  // Exception event is always interactive
+      sendEventMessage = true;
       break;
     case v8::BeforeCompile:
       break;
     case v8::AfterCompile:
+      sendEventMessage = true;
       break;
     case v8::NewFunction:
       break;
     default:
       UNREACHABLE();
   }
 
-  // Done if not interactive.
-  if (!interactive) return;
+  // The debug command interrupt flag might have been set when the command was
+  // added. It should be enough to clear the flag only once while we are in the
+  // debugger.
+  ASSERT(Debug::InDebugger());
+  StackGuard::Continue(DEBUGCOMMAND);
+
+  // Notify the debugger that a debug event has occurred unless auto continue is
+  // active in which case no event is send.
+  if (sendEventMessage) {
+    InvokeMessageHandlerWithEvent(event_data);
+  }
+  if (auto_continue && !HasCommands()) {
+    return;
+  }
 
   // Get the DebugCommandProcessor.
   v8::Local<v8::Object> api_exec_state =
       v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state));
   v8::Local<v8::String> fun_name =
       v8::String::New("debugCommandProcessor");
   v8::Local<v8::Function> fun =
       v8::Function::Cast(*api_exec_state->Get(fun_name));
   v8::TryCatch try_catch;
   v8::Local<v8::Object> cmd_processor =
       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 unless auto continue is
-  // active in which case no event is send.
-  if (!auto_continue) {
-    bool success = InvokeMessageHandlerWithEvent(event_data);
-    if (!success) {
-      // If failed to notify debugger just continue running.
-      return;
-    }
-  }
-
   // Process requests from the debugger.
   while (true) {
     // Wait for new command in the queue.
     if (Debugger::host_dispatch_handler_) {
       // In case there is a host dispatch - do periodic dispatches.
       if (!command_received_->Wait(host_dispatch_micros_)) {
         // Timout expired, do the dispatch.
         Debugger::host_dispatch_handler_();
         continue;
       }
     } else {
       // In case there is no host dispatch - just wait.
       command_received_->Wait();
     }
 
-    // The debug command interrupt flag might have been set when the command was
-    // added.
-    StackGuard::Continue(DEBUGCOMMAND);
-
     // Get the command from the queue.
     CommandMessage command = command_queue_.Get();
     Logger::DebugTag("Got request from command queue, in interactive loop.");
     if (!Debugger::IsDebuggerActive()) {
       // Delete command text and user data.
       command.Dispose();
       return;
     }
 
     // Invoke JavaScript to process the debug request.
@@ skipping 355 matching lines @@
 
 
 void LockingCommandMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal