Handle vmservice messages while at breakpoint.

runtime/vm/debugger.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 "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
+#include "vm/json_stream.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
@@ skipping 50 matching lines @@
 
 RawScript* SourceBreakpoint::SourceCode() {
   const Function& func = Function::Handle(function_);
   return func.script();
 }
 
 
 void SourceBreakpoint::GetCodeLocation(
     Library* lib,
     Script* script,
-    intptr_t* pos) {
+    intptr_t* pos) const {
   const Function& func = Function::Handle(function_);
   const Class& cls = Class::Handle(func.origin());
   *lib = cls.library();
   *script = func.script();
   *pos = token_pos();
 }
 
 
 RawString* SourceBreakpoint::SourceUrl() {
   const Script& script = Script::Handle(SourceCode());
@@ skipping 14 matching lines @@
 void SourceBreakpoint::set_function(const Function& func) {
   function_ = func.raw();
 }
 
 
 void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
+void SourceBreakpoint::PrintToJSONStream(JSONStream* stream) const {
+  Isolate* isolate = Isolate::Current();
+
+  JSONObject jsobj(stream);
+  jsobj.AddProperty("type", "Breakpoint");
+
+  jsobj.AddProperty("id", id());
+  jsobj.AddProperty("enabled", IsEnabled());
+
+  const Function& func = Function::Handle(function());
+  jsobj.AddProperty("resolved", func.HasCode());
+
+  Library& library = Library::Handle(isolate);
+  Script& script = Script::Handle(isolate);
+  intptr_t token_pos;
+  GetCodeLocation(&library, &script, &token_pos);
+  {
+    JSONObject location(&jsobj, "location");
+    location.AddProperty("type", "Location");
+    location.AddProperty("libId", library.index());
+
+    const String& url = String::Handle(script.url());
+    location.AddProperty("script", url.ToCString());
+    location.AddProperty("tokenPos", token_pos);
+  }
+}
+
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
+
 ActivationFrame::ActivationFrame(
     uword pc,
     uword fp,
     uword sp,
     const Code& code,
     const Array& deopt_frame,
     intptr_t deopt_frame_offset)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
@@ skipping 75 matching lines @@
   while (cbpt != NULL) {
     if (func.raw() == cbpt->function()) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
 
+void Debugger::PrintBreakpointsToJSONArray(JSONArray* jsarr) const {
+  SourceBreakpoint* sbpt = src_breakpoints_;
+  while (sbpt != NULL) {
+    jsarr->AddValue(sbpt);
+    sbpt = sbpt->next_;
+  }
+}
+
+
 RawString* ActivationFrame::QualifiedFunctionName() {
   return String::New(Debugger::QualifiedFunctionName(function()));
 }
 
 
 RawString* ActivationFrame::SourceUrl() {
   const Script& script = Script::Handle(SourceScript());
   return script.url();
 }
 
@@ skipping 1207 matching lines @@
 SourceBreakpoint* Debugger::SetBreakpointAtEntry(
       const Function& target_function) {
   ASSERT(!target_function.IsNull());
   return SetBreakpoint(target_function,
                        target_function.token_pos(),
                        target_function.end_token_pos());
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
-                                          intptr_t line_number) {
+                                                intptr_t line_number) {
   Library& lib = Library::Handle(isolate_);
   Script& script = Script::Handle(isolate_);
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
@@ skipping 636 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart