Implement 'print', 'up', 'down', and 'frame' commands in the Observatory debugger.

runtime/vm/service.cc

 // Copyright (c) 2013, 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/service.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 445 matching lines @@
     const char* c_method_name = method_name.ToCString();
 
     ServiceMethodDescriptor* method = FindMethod(c_method_name);
     if (method != NULL) {
       if (!ValidateParameters(method->parameters, &js)) {
         js.PostReply();
         return;
       }
       if (method->entry(isolate, &js)) {
         js.PostReply();
+      } else {
+        // NOTE(turnidge): All message handlers currently return true,
+        // so this case shouldn't be reached, at present.
+        UNIMPLEMENTED();
       }
       return;
     }
 
     EmbedderServiceHandler* handler = FindIsolateEmbedderHandler(c_method_name);
     if (handler == NULL) {
       handler = FindRootEmbedderHandler(c_method_name);
     }
 
     if (handler != NULL) {
@@ skipping 39 matching lines @@
 bool Service::NeedsGCEvents() {
   return NeedsEvents() && EventMaskHas(kEventFamilyGCMask);
 }
 
 
 void Service::SetEventMask(uint32_t mask) {
   event_mask_ = mask;
 }
 
 
-void Service::SendEvent(intptr_t eventId, const Object& eventMessage) {
+void Service::SendEvent(intptr_t eventFamilyId,
+                        intptr_t eventType,
+                        const Object& eventMessage) {
   if (!ServiceIsolate::IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
 
-  // Construct a list of the form [eventId, eventMessage].
+  // Construct a list of the form [eventFamilyId, eventMessage].
+  //
+  // TODO(turnidge): Revisit passing the eventFamilyId here at all.
   const Array& list = Array::Handle(Array::New(2));
   ASSERT(!list.IsNull());
-  list.SetAt(0, Integer::Handle(Integer::New(eventId)));
+  list.SetAt(0, Integer::Handle(Integer::New(eventFamilyId)));
   list.SetAt(1, eventMessage);
 
   // Push the event to port_.
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("vm-service: Pushing event of type %" Pd ", len %" Pd "\n",
-              eventId, len);
+              eventType, len);
   }
   // TODO(turnidge): For now we ignore failure to send an event.  Revisit?
   PortMap::PostMessage(
       new Message(ServiceIsolate::Port(), data, len, Message::kNormalPriority));
 }
 
 
-void Service::SendEvent(intptr_t eventId,
+void Service::SendEvent(intptr_t eventFamilyId,
                         const String& meta,
                         const uint8_t* data,
                         intptr_t size) {
   // Bitstream: [meta data size (big-endian 64 bit)] [meta data (UTF-8)] [data]
   const intptr_t meta_bytes = Utf8::Length(meta);
   const intptr_t total_bytes = sizeof(uint64_t) + meta_bytes + size;
   const TypedData& message = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, total_bytes));
   intptr_t offset = 0;
   // TODO(koda): Rename these methods SetHostUint64, etc.
   message.SetUint64(0, Utils::HostToBigEndian64(meta_bytes));
   offset += sizeof(uint64_t);
   {
     NoGCScope no_gc;
     meta.ToUTF8(static_cast<uint8_t*>(message.DataAddr(offset)), meta_bytes);
     offset += meta_bytes;
   }
   // TODO(koda): It would be nice to avoid this copy (requires changes to
   // MessageWriter code).
   {
     NoGCScope no_gc;
     memmove(message.DataAddr(offset), data, size);
     offset += size;
   }
   ASSERT(offset == total_bytes);
-  SendEvent(eventId, message);
+  // TODO(turnidge): Pass the real eventType here.
+  SendEvent(eventFamilyId, 0, message);
 }
 
 
 void Service::HandleGCEvent(GCEvent* event) {
   JSONStream js;
   event->PrintJSON(&js);
   const String& message = String::Handle(String::New(js.ToCString()));
-  SendEvent(kEventFamilyGC, message);
+  // TODO(turnidge): Pass the real eventType here.
+  SendEvent(kEventFamilyGC, 0, message);
 }
 
 
 void Service::HandleEvent(ServiceEvent* event) {
   JSONStream js;
   event->PrintJSON(&js);
   const String& message = String::Handle(String::New(js.ToCString()));
-  SendEvent(kEventFamilyDebug, message);
+  SendEvent(kEventFamilyDebug, event->type(), message);
 }
 
 
 class EmbedderServiceHandler {
  public:
   explicit EmbedderServiceHandler(const char* name) : name_(NULL),
                                                       callback_(NULL),
                                                       user_data_(NULL),
                                                       next_(NULL) {
     ASSERT(name != NULL);
@@ skipping 905 matching lines @@
     result.PrintJSON(js, true);
     return true;
   }
   PrintError(js, "%s: Invalid 'targetId' parameter value: "
              "id '%s' does not correspond to a "
              "library, class, or instance", js->method(), target_id);
   return true;
 }
 
 
+static const MethodParameter* eval_frame_params[] = {
+  ISOLATE_PARAMETER,
+  new UIntParameter("frame", true),
+  new MethodParameter("expression", true),
+  NULL,
+};
+
+
+static bool EvalFrame(Isolate* isolate, JSONStream* js) {
+  DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
+  intptr_t framePos = UIntParameter::Parse(js->LookupParam("frame"));
+  if (framePos > stack->Length()) {
+    PrintInvalidParamError(js, "frame");
+    return true;
+  }
+  ActivationFrame* frame = stack->FrameAt(framePos);
+
+  const char* expr = js->LookupParam("expression");
+  const String& expr_str = String::Handle(isolate, String::New(expr));
+
+  const Object& result = Object::Handle(frame->Evaluate(expr_str));
+  result.PrintJSON(js, true);
+  return true;
+}
+
+
 static const MethodParameter* get_call_site_data_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("targetId", true),
   NULL,
 };
 
 
 static bool GetCallSiteData(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id, NULL));
@@ skipping 967 matching lines @@
   { "_triggerEchoEvent", _TriggerEchoEvent,
     NULL },
   { "addBreakpoint", AddBreakpoint,
     add_breakpoint_params },
   { "addBreakpointAtEntry", AddBreakpointAtEntry,
     add_breakpoint_at_entry_params },
   { "clearCpuProfile", ClearCpuProfile,
     clear_cpu_profile_params },
   { "eval", Eval,
     eval_params },
+  { "evalFrame", EvalFrame,
+    eval_frame_params },
   { "getAllocationProfile", GetAllocationProfile,
     get_allocation_profile_params },
   { "getCallSiteData", GetCallSiteData,
     get_call_site_data_params },
   { "getClassList", GetClassList,
     get_class_list_params },
   { "getCoverage", GetCoverage,
     get_coverage_params },
   { "getCpuProfile", GetCpuProfile,
     get_cpu_profile_params },
@@ skipping 51 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart