Add OnCompileError handler and v8::CompileError debug event

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
 #include "api.h"
 #include "arguments.h"
 #include "bootstrapper.h"
 #include "code-stubs.h"
@@ skipping 2667 matching lines @@
           exception, uncaught, promise).ToHandle(&event_data)) {
     return;
   }
 
   // Process debug event.
   ProcessDebugEvent(event, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
+void Debugger::OnSyntaxError(Handle<Script> script) {
+  HandleScope scope(isolate_);
+  Debug* debug = isolate_->debug();
+
+  // No more to do if not debugging.
+  if (!IsDebuggerActive()) return;
+
+  // No compile events while compiling natives.
+  if (compiling_natives()) return;
+
+  // Store whether in debugger before entering debugger.
+  bool in_debugger = debug->InDebugger();
+
+  // Enter the debugger.
+  EnterDebugger debugger(isolate_);
+  if (debugger.FailedToEnter()) return;
+
+  // Save breakpoints or not, if SyntaxError ocured?

[vsevik, 2014/06/06 16:12:01]

I don't think we should care about breakpoints in a script with syntax error.

+
+  // 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-debugger.js).
+  Handle<String> update_script_break_points_string =
+      isolate_->factory()->InternalizeOneByteString(
+          STATIC_ASCII_VECTOR("UpdateScriptBreakPoints"));
+  Handle<GlobalObject> debug_global(debug->debug_context()->global_object());
+  Handle<Object> update_script_break_points =
+      Object::GetProperty(
+          debug_global, update_script_break_points_string).ToHandleChecked();
+  if (!update_script_break_points->IsJSFunction()) {
+    return;
+  }
+  ASSERT(update_script_break_points->IsJSFunction());
+
+  // Wrap the script object in a proper JS object before passing it
+  // to JavaScript.
+  Handle<Object> wrapper = Script::GetWrapper(script);
+
+  // Call UpdateScriptBreakPoints expect no exceptions.
+  Handle<Object> argv[] = { wrapper };
+  if (Execution::TryCall(Handle<JSFunction>::cast(update_script_break_points),
+                         isolate_->js_builtins_object(),
+                         ARRAY_SIZE(argv),
+                         argv).is_null()) {
+    return;
+  }
+  // Bail out based on state or if there is no listener for this event
+  if (!Debugger::EventActive(v8::AfterCompile)) return;
+
+  // Create the compile state object.
+  Handle<Object> event_data;
+  // Bail out and don't call debugger if exception.
+  if (!MakeCompileEvent(script, false).ToHandle(&event_data)) return;
+
+  // Process debug event.
+  ProcessDebugEvent(v8::ScriptFailedToParse,
+                    Handle<JSObject>::cast(event_data), true);
+}
+
+
 void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
                             bool auto_continue) {
   HandleScope scope(isolate_);
 
   // Debugger has already been entered by caller.
   ASSERT(isolate_->context() == *isolate_->debug()->debug_context());
 
   // Bail out if there is no listener for this event
   if (!Debugger::EventActive(v8::Break)) return;
 
@@ skipping 1022 matching lines @@
       already_signalled_ = false;
     }
     {
       Locker locker(reinterpret_cast<v8::Isolate*>(isolate_));
       isolate_->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 } }  // namespace v8::internal