Fixed the debugger compile events....

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 1380 matching lines @@
                                               bool* caught_exception) {
   // Create the new function event object.
   const int argc = 1;
   Object** argv[argc] = { function.location() };
   return MakeJSObject(CStrVector("MakeNewFunctionEvent"),
                       argc, argv, caught_exception);
 }
 
 
 Handle<Object> Debugger::MakeCompileEvent(Handle<Script> script,
-                                          Handle<Object> script_function,
+                                          bool before,
                                           bool* caught_exception) {
   // Create the compile event object.
   Handle<Object> exec_state = MakeExecutionState(caught_exception);
-  Handle<Object> script_source(script->source());
-  Handle<Object> script_name(script->name());
+  Handle<Object> script_wrapper = GetScriptWrapper(script);
   const int argc = 3;
-  Object** argv[argc] = { script_source.location(),
-                          script_name.location(),
-                          script_function.location() };
+  Object** argv[argc] = { exec_state.location(),
+                          script_wrapper.location(),
+                          before ? Factory::true_value().location() :
+                                   Factory::false_value().location() };
+
   return MakeJSObject(CStrVector("MakeCompileEvent"),
                       argc,
                       argv,
                       caught_exception);
 }
 
 
 void Debugger::OnException(Handle<Object> exception, bool uncaught) {
   HandleScope scope;
 
@@ skipping 73 matching lines @@
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!EventActive(v8::BeforeCompile)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event data object.
   bool caught_exception = false;
-  Handle<Object> event_data = MakeCompileEvent(script,
-                                               Factory::undefined_value(),
-                                               &caught_exception);
+  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);
 }
 
 
 // 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;
 
   // No more to do if not debugging.
   if (!debugger_active()) return;
 
+  // Store whether in debugger before entering debugger.
+  bool in_debugger = Debug::InDebugger();
+
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // If debugging there might be script break points registered for this
   // script. Make sure that these break points are set.
 
   // Get the function UpdateScriptBreakPoints (defined in debug-delay.js).
   Handle<Object> update_script_break_points =
       Handle<Object>(Debug::debug_context()->global()->GetProperty(
@@ skipping 12 matching lines @@
   const int argc = 1;
   Object** argv[argc] = { reinterpret_cast<Object**>(wrapper.location()) };
   Handle<Object> result = Execution::TryCall(
       Handle<JSFunction>::cast(update_script_break_points),
       Top::builtins(), argc, argv,
       &caught_exception);
   if (caught_exception) {
     return;
   }
   // Bail out based on state or if there is no listener for this event
-  if (Debug::InDebugger()) return;
+  if (in_debugger) return;
   if (!Debugger::EventActive(v8::AfterCompile)) return;
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
-                                               Factory::undefined_value(),
+                                               false,
                                                &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event
   ProcessDebugEvent(v8::AfterCompile, event_data);
 }
 
 
@@ skipping 458 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal