Debugger wire protocol: setting breakpoints

runtime/vm/debugger_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_debugger_api.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
@@ skipping 66 matching lines @@
                      Dart_BreakpointHandler bp_handler) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   BreakpointHandler* handler =
       reinterpret_cast<BreakpointHandler*>(bp_handler);
 
   isolate->debugger()->SetBreakpointHandler(handler);
 }
 
 
+static Dart_BreakpointResolvedHandler* bp_resolved_handler = NULL;
+
+static void DebuggerEventHandler(Debugger::DebuggerEvent* event) {
+  printf("Debugger event %d\n", event->type);
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  if (event->type == Debugger::kBreakpointResolved) {
+    if (bp_resolved_handler == NULL) {
+      return;
+    }
+    SourceBreakpoint* bpt = event->breakpoint;
+    ASSERT(bpt != NULL);
+    Dart_Handle url = Api::NewHandle(isolate, bpt->SourceUrl());
+    (*bp_resolved_handler)(bpt->id(), url, bpt->LineNumber());
+  } else {
+    UNIMPLEMENTED();
+  }
+}
+
+
+DART_EXPORT void Dart_SetBreakpointResolvedHandler(
+                            Dart_BreakpointResolvedHandler handler) {
+  bp_resolved_handler = handler;
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  isolate->debugger()->SetEventHandler(DebuggerEventHandler);
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetStackTrace(Dart_StackTrace* trace) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  CHECK_NOT_NULL(trace);
+  *trace = reinterpret_cast<Dart_StackTrace>(isolate->debugger()->StackTrace());
+  return Api::True(isolate);
+}
+
+
 DART_EXPORT Dart_Handle Dart_ActivationFrameInfo(
                             Dart_ActivationFrame activation_frame,
                             Dart_Handle* function_name,
                             Dart_Handle* script_url,
                             intptr_t* line_number) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_AND_CAST(ActivationFrame, frame, activation_frame);
   if (function_name != NULL) {
     *function_name = Api::NewHandle(isolate, frame->QualifiedFunctionName());
@@ skipping 10 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_GetLocalVariables(
                             Dart_ActivationFrame activation_frame) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_AND_CAST(ActivationFrame, frame, activation_frame);
   return Api::NewHandle(isolate, frame->GetLocalVariables());
 }
 
 
+DART_EXPORT Dart_Handle Dart_SetBreakpoint(
+                            Dart_Handle script_url_in,
+                            intptr_t line_number) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+
+  String& script_url = String::Handle();
+  UNWRAP_AND_CHECK_PARAM(String, script_url, script_url_in);
+
+  Debugger* debugger = isolate->debugger();
+  ASSERT(debugger != NULL);
+  SourceBreakpoint* bpt =
+      debugger->SetBreakpointAtLine(script_url, line_number);
+  if (bpt == NULL) {
+    return Api::NewError("%s: could not set breakpoint at line %d in '%s'",
+                         CURRENT_FUNC, line_number, script_url.ToCString());
+  }
+  return Dart_NewInteger(bpt->id());
+}
+
+
+// TODO(hausner): remove this function.
 DART_EXPORT Dart_Handle Dart_SetBreakpointAtLine(
                             Dart_Handle script_url_in,
                             Dart_Handle line_number_in,
                             Dart_Breakpoint* breakpoint) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   String& script_url = String::Handle();
   Integer& line_number = Integer::Handle();
   UNWRAP_AND_CHECK_PARAM(String, script_url, script_url_in);
@@ skipping 19 matching lines @@
   if (bpt == NULL) {
     result = Api::NewError("%s: could not set breakpoint at line %d of '%s'",
                              CURRENT_FUNC, line, script_url.ToCString());
   } else {
     *breakpoint = reinterpret_cast<Dart_Breakpoint>(bpt);
   }
   return result;
 }
 
 
+DART_EXPORT Dart_Handle Dart_GetBreakpointURL(intptr_t bp_id) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Debugger* debugger = isolate->debugger();
+  ASSERT(debugger != NULL);
+
+  SourceBreakpoint* bpt = debugger->GetBreakpointById(bp_id);
+  if (bpt == NULL) {
+    return Api::NewError("%s: breakpoint with id %d does not exist",
+                           CURRENT_FUNC, bp_id);
+  }
+  return Api::NewHandle(isolate, bpt->SourceUrl());
+}
+
+
+DART_EXPORT Dart_Handle Dart_GetBreakpointLine(intptr_t bp_id) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Debugger* debugger = isolate->debugger();
+  ASSERT(debugger != NULL);
+
+  SourceBreakpoint* bpt = debugger->GetBreakpointById(bp_id);
+  if (bpt == NULL) {
+    return Api::NewError("%s: breakpoint with id %d does not exist",
+                         CURRENT_FUNC, bp_id);
+  }
+  return Dart_NewInteger(bpt->LineNumber());
+}
+
+
 DART_EXPORT Dart_Handle Dart_SetBreakpointAtEntry(
                             Dart_Handle library_in,
                             Dart_Handle class_name_in,
                             Dart_Handle function_name_in,
                             Dart_Breakpoint* breakpoint) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   Library& library = Library::Handle();
   String& class_name = String::Handle();
@@ skipping 29 matching lines @@
     const char* target_name = Debugger::QualifiedFunctionName(bp_target);
     result = Api::NewError("%s: no breakpoint location found in '%s'",
                              CURRENT_FUNC, target_name);
   } else {
     *breakpoint = reinterpret_cast<Dart_Breakpoint>(bpt);
   }
   return result;
 }
 
 
+DART_EXPORT Dart_Handle Dart_RemoveBreakpoint(intptr_t bp_id) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Debugger* debugger = isolate->debugger();
+  ASSERT(debugger != NULL);
+
+  isolate->debugger()->RemoveBreakpoint(bp_id);
+  return Api::True(isolate);
+}
+
+
 DART_EXPORT Dart_Handle Dart_DeleteBreakpoint(
                             Dart_Breakpoint breakpoint_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   CHECK_AND_CAST(SourceBreakpoint, breakpoint, breakpoint_in);
-  isolate->debugger()->RemoveBreakpoint(breakpoint);
+  isolate->debugger()->RemoveBreakpoint(breakpoint->id());
   return Api::True(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetStepOver() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   isolate->debugger()->SetStepOver();
   return Api::True(isolate);
 }
@@ skipping 125 matching lines @@
   for (int i = 0; i < num_libs; i++) {
     ASSERT(!lib.IsNull());
     lib_url = lib.url();
     library_list.SetAt(i, lib_url);
     lib = lib.next_registered();
   }
   return Api::NewHandle(isolate, library_list.raw());
 }
 
 }  // namespace dart