Support for lists in debugger wire protocol

runtime/bin/dbg_connection.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 "bin/dbg_connection.h"
 #include "bin/dartutils.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
@@ skipping 37 matching lines @@
 class MessageBuffer {
  public:
   explicit MessageBuffer(int fd);
   ~MessageBuffer();
   void ReadData();
   bool IsValidMessage() const;
   void PopMessage();
   int MessageId() const;
   const char* Params() const;
   intptr_t GetIntParam(const char* name) const;
+  intptr_t GetOptIntParam(const char* name, intptr_t default_val) const;
   // GetStringParam mallocs the buffer that it returns. Caller must free.
   char* GetStringParam(const char* name) const;
   char* buf() const { return buf_; }
   bool Alive() const { return connection_is_alive_; }
 
  private:
   static const int kInitialBufferSize = 256;
   char* buf_;
   int buf_length_;
   int fd_;
@@ skipping 60 matching lines @@
 
 intptr_t MessageBuffer::GetIntParam(const char* name) const {
   const char* params = Params();
   ASSERT(params != NULL);
   dart::JSONReader r(params);
   r.Seek(name);
   ASSERT(r.Type() == dart::JSONReader::kInteger);
   return strtol(r.ValueChars(), NULL, 10);
 }
 
+
+intptr_t MessageBuffer::GetOptIntParam(const char* name,
+                                       intptr_t default_val) const {
+  const char* params = Params();
+  ASSERT(params != NULL);
+  dart::JSONReader r(params);
+  r.Seek(name);
+  if (r.Type() == dart::JSONReader::kInteger) {
+    return strtol(r.ValueChars(), NULL, 10);
+  } else {
+    return default_val;
+  }
+}
+
+
 char* MessageBuffer::GetStringParam(const char* name) const {
   const char* params = Params();
   ASSERT(params != NULL);
   dart::JSONReader pr(params);
   pr.Seek(name);
   if (pr.Type() != dart::JSONReader::kString) {
     return NULL;
   }
   intptr_t buflen = pr.ValueLen() + 1;
   char* param_chars = reinterpret_cast<char*>(malloc(buflen));
@@ skipping 254 matching lines @@
     ASSERT(Dart_IsString(lib_url));
     msg.Printf("%s{\"id\":%d,\"url\":", (i == 0) ? "" : ", ", lib_id);
     FormatEncodedString(&msg, lib_url);
     msg.Printf("}");
   }
   msg.Printf("]}}");
   SendMsg(&msg);
 }
 
 
-static void FormatRemoteObj(dart::TextBuffer* buf, Dart_Handle object) {
-  intptr_t obj_id = Dart_CacheObject(object);
-  ASSERT(obj_id >= 0);
-  buf->Printf("{\"objectId\":%d,", obj_id);
-  const char* kind = "object";
-  if (Dart_IsInteger(object)) {
-    kind = "integer";
-  } else if (Dart_IsString(object)) {
-    kind = "string";
-  } else if (Dart_IsBoolean(object)) {
-    kind = "boolean";
-  }
-  buf->Printf("\"kind\":\"%s\",", kind);
-  buf->Printf("\"text\":");
+static void FormatTextualValue(dart::TextBuffer* buf, Dart_Handle object) {
   Dart_Handle text;
   if (Dart_IsNull(object)) {
     text = Dart_Null();
   } else {
     text = Dart_ToString(object);
   }
+  buf->Printf("\"text\":");
   if (Dart_IsNull(text)) {
     buf->Printf("null");
   } else if (Dart_IsError(text)) {
     FormatErrorMsg(buf, text);
   } else {
     FormatEncodedString(buf, text);
   }
+}
+
+
+static void FormatValue(dart::TextBuffer* buf, Dart_Handle object) {
+  if (Dart_IsInteger(object)) {
+    buf->Printf("\"kind\":\"integer\",");
+  } else if (Dart_IsString(object)) {
+    buf->Printf("\"kind\":\"string\",");
+  } else if (Dart_IsBoolean(object)) {
+    buf->Printf("\"kind\":\"boolean\",");
+  } else if (Dart_IsList(object)) {
+    intptr_t len = 0;
+    Dart_Handle res = Dart_ListLength(object, &len);
+    ASSERT_NOT_ERROR(res);
+    buf->Printf("\"kind\":\"list\",\"length\":%d,", len);
+  } else {
+    buf->Printf("\"kind\":\"object\",");
+  }
+  FormatTextualValue(buf, object);
+}
+
+
+static void FormatValueObj(dart::TextBuffer* buf, Dart_Handle object) {
+  buf->Printf("{");
+  FormatValue(buf, object);
   buf->Printf("}");
 }
 
 
-static void FormatField(dart::TextBuffer* buf,
-                        Dart_Handle object_name,
-                        Dart_Handle object) {
+static void FormatRemoteObj(dart::TextBuffer* buf, Dart_Handle object) {
+  intptr_t obj_id = Dart_CacheObject(object);
+  ASSERT(obj_id >= 0);
+  buf->Printf("{\"objectId\":%d,", obj_id);
+  FormatValue(buf, object);
+  buf->Printf("}");
+}
+
+
+static void FormatNamedValue(dart::TextBuffer* buf,
+                             Dart_Handle object_name,
+                             Dart_Handle object) {
   ASSERT(Dart_IsString(object_name));
   buf->Printf("{\"name\":\"%s\",", GetStringChars(object_name));
   buf->Printf("\"value\":");
   FormatRemoteObj(buf, object);
   buf->Printf("}");
 }
 
 
-static void FormatFieldList(dart::TextBuffer* buf,
-                            Dart_Handle obj_list) {
+static void FormatNamedValueList(dart::TextBuffer* buf,
+                                 Dart_Handle obj_list) {
   ASSERT(Dart_IsList(obj_list));
   intptr_t list_length = 0;
   Dart_Handle res = Dart_ListLength(obj_list, &list_length);
   ASSERT_NOT_ERROR(res);
   ASSERT(list_length % 2 == 0);
   buf->Printf("[");
   for (int i = 0; i + 1 < list_length; i += 2) {
     Dart_Handle name_handle = Dart_ListGetAt(obj_list, i);
     ASSERT_NOT_ERROR(name_handle);
     Dart_Handle value_handle = Dart_ListGetAt(obj_list, i + 1);
     ASSERT_NOT_ERROR(value_handle);
     if (i > 0) {
       buf->Printf(",");
     }
-    FormatField(buf, name_handle, value_handle);
+    FormatNamedValue(buf, name_handle, value_handle);
   }
   buf->Printf("]");
 }
 
 
 static const char* FormatClassProps(dart::TextBuffer* buf,
                                     intptr_t cls_id) {
   Dart_Handle name, static_fields;
   intptr_t super_id = -1;
   intptr_t library_id = -1;
   Dart_Handle res =
       Dart_GetClassInfo(cls_id, &name, &library_id, &super_id, &static_fields);
   RETURN_IF_ERROR(res);
   RETURN_IF_ERROR(name);
   buf->Printf("{\"name\":\"%s\",", GetStringChars(name));
   if (super_id > 0) {
     buf->Printf("\"superclassId\":%d,", super_id);
   }
   buf->Printf("\"libraryId\":%d,", library_id);
   RETURN_IF_ERROR(static_fields);
   buf->Printf("\"fields\":");
-  FormatFieldList(buf, static_fields);
+  FormatNamedValueList(buf, static_fields);
   buf->Printf("}");
   return NULL;
 }
 
 
 static const char* FormatLibraryProps(dart::TextBuffer* buf,
                                       intptr_t lib_id) {
   Dart_Handle url = Dart_GetLibraryURL(lib_id);
   RETURN_IF_ERROR(url);
   buf->Printf("{\"url\":");
@@ skipping 18 matching lines @@
     ASSERT_NOT_ERROR(name);
     buf->Printf("\"prefix\":\"%s\"}",
                 Dart_IsNull(name) ? "" : GetStringChars(name));
   }
   buf->Printf("],");
 
   // Global variables in the library.
   Dart_Handle global_vars = Dart_GetLibraryFields(lib_id);
   RETURN_IF_ERROR(global_vars);
   buf->Printf("\"globals\":");
-  FormatFieldList(buf, global_vars);
+  FormatNamedValueList(buf, global_vars);
   buf->Printf("}");
   return NULL;
 }
 
 
 static const char* FormatObjProps(dart::TextBuffer* buf,
                                   Dart_Handle object) {
   intptr_t class_id;
   if (Dart_IsNull(object)) {
     buf->Printf("{\"classId\":-1,\"fields\":[]}");
     return NULL;
   }
   Dart_Handle res = Dart_GetObjClassId(object, &class_id);
   RETURN_IF_ERROR(res);
-  buf->Printf("{\"classId\": %d, \"fields\":", class_id);
+  buf->Printf("{\"classId\": %d,", class_id);
+  buf->Printf("\"kind\":\"object\",\"fields\":");
   Dart_Handle fields = Dart_GetInstanceFields(object);
   RETURN_IF_ERROR(fields);
-  FormatFieldList(buf, fields);
+  FormatNamedValueList(buf, fields);
   buf->Printf("}");
   return NULL;
 }
 
 
+static const char* FormatListSlice(dart::TextBuffer* buf,
+                                   Dart_Handle list,
+                                   intptr_t list_length,
+                                   intptr_t index,
+                                   intptr_t slice_length) {
+  intptr_t end_index = index + slice_length;
+  ASSERT(end_index <= list_length);
+  buf->Printf("{\"index\":%d,", index);
+  buf->Printf("\"length\":%d,", slice_length);
+  buf->Printf("\"elements\":[");
+  for (intptr_t i = index; i < end_index; i++) {
+    Dart_Handle value = Dart_ListGetAt(list, i);
+    if (i > index) {
+      buf->Printf(",");
+    }
+    FormatValueObj(buf, value);
+  }
+  buf->Printf("]}");
+  return NULL;
+}
+
+
 static void FormatCallFrames(dart::TextBuffer* msg, Dart_StackTrace trace) {
   intptr_t trace_len = 0;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   ASSERT_NOT_ERROR(res);
   msg->Printf("\"callFrames\" : [ ");
   for (int i = 0; i < trace_len; i++) {
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
     ASSERT_NOT_ERROR(res);
     Dart_Handle func_name;
     Dart_Handle script_url;
     intptr_t line_number = 0;
     intptr_t library_id = 0;
     res = Dart_ActivationFrameInfo(
         frame, &func_name, &script_url, &line_number, &library_id);
     ASSERT_NOT_ERROR(res);
     ASSERT(Dart_IsString(func_name));
     msg->Printf("%s{\"functionName\":", (i > 0) ? "," : "");
     FormatEncodedString(msg, func_name);
     msg->Printf(",\"libraryId\": %d,", library_id);
 
     ASSERT(Dart_IsString(script_url));
     msg->Printf("\"location\": { \"url\":");
     FormatEncodedString(msg, script_url);
     msg->Printf(",\"lineNumber\":%d},", line_number);
 
     Dart_Handle locals = Dart_GetLocalVariables(frame);
     ASSERT_NOT_ERROR(locals);
     msg->Printf("\"locals\":");
-    FormatFieldList(msg, locals);
+    FormatNamedValueList(msg, locals);
     msg->Printf("}");
   }
   msg->Printf("]");
 }
 
 
 void DebuggerConnectionHandler::HandleGetStackTraceCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   Dart_StackTrace trace;
   Dart_Handle res = Dart_GetStackTrace(&trace);
@@ skipping 80 matching lines @@
   const char* err = FormatObjProps(&msg, obj);
   if (err != NULL) {
     SendError(msg_id, err);
     return;
   }
   msg.Printf("}");
   SendMsg(&msg);
 }
 
 
+void DebuggerConnectionHandler::HandleGetListCmd(const char* json_msg) {
+  const intptr_t kDefaultSliceLength = 100;
+  int msg_id = msgbuf_->MessageId();
+  intptr_t obj_id = msgbuf_->GetIntParam("objectId");
+  Dart_Handle list = Dart_GetCachedObject(obj_id);
+  if (Dart_IsError(list)) {
+    SendError(msg_id, Dart_GetError(list));
+    return;
+  }
+  if (!Dart_IsList(list)) {
+    SendError(msg_id, "object is not a list");
+    return;
+  }
+  intptr_t list_length = 0;
+  Dart_Handle res = Dart_ListLength(list, &list_length);
+  if (Dart_IsError(res)) {
+    SendError(msg_id, Dart_GetError(res));
+    return;
+  }
+
+  intptr_t index = msgbuf_->GetIntParam("index");
+  if (index < 0) {
+    index = 0;
+  } else if (index > list_length) {
+    index = list_length;
+  }
+
+  // If no slice length is given, get only one element. If slice length
+  // is given as 0, get entire list.
+  intptr_t slice_length = msgbuf_->GetOptIntParam("length", 1);
+  if (slice_length == 0) {
+    slice_length = list_length - index;
+  }
+  if ((index + slice_length) > list_length) {
+    slice_length = list_length - index;
+  }
+  ASSERT(slice_length >= 0);
+  if (slice_length > kDefaultSliceLength) {
+    slice_length = kDefaultSliceLength;
+  }
+  dart::TextBuffer msg(64);
+  msg.Printf("{\"id\":%d, \"result\":", msg_id);
+  if (slice_length == 1) {
+    Dart_Handle value = Dart_ListGetAt(list, index);
+    FormatRemoteObj(&msg, value);
+  } else {
+    FormatListSlice(&msg, list, list_length, index, slice_length);
+  }
+  msg.Printf("}");
+  SendMsg(&msg);
+}
+
+
 void DebuggerConnectionHandler::HandleGetClassPropsCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   intptr_t cls_id = msgbuf_->GetIntParam("classId");
   dart::TextBuffer msg(64);
   msg.Printf("{\"id\":%d, \"result\":", msg_id);
   const char* err = FormatClassProps(&msg, cls_id);
   if (err != NULL) {
     SendError(msg_id, err);
     return;
   }
@@ skipping 17 matching lines @@
 }
 
 
 void DebuggerConnectionHandler::HandleGetGlobalsCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   intptr_t lib_id = msgbuf_->GetIntParam("libraryId");
   dart::TextBuffer msg(64);
   msg.Printf("{\"id\":%d, \"result\": { \"globals\":", msg_id);
   Dart_Handle globals = Dart_GetGlobalVariables(lib_id);
   ASSERT_NOT_ERROR(globals);
-  FormatFieldList(&msg, globals);
+  FormatNamedValueList(&msg, globals);
   msg.Printf("}}");
   SendMsg(&msg);
 }
 
 
 void DebuggerConnectionHandler::HandleUnknownMsg(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   ASSERT(msg_id >= 0);
   SendError(msg_id, "unknown debugger command");
 }
 
 
 void DebuggerConnectionHandler::HandleMessages() {
   static JSONDebuggerCommand debugger_commands[] = {
     { "resume", HandleResumeCmd },
     { "getLibraries", HandleGetLibrariesCmd },
     { "getClassProperties", HandleGetClassPropsCmd },
     { "getLibraryProperties", HandleGetLibPropsCmd },
     { "getObjectProperties", HandleGetObjPropsCmd },
+    { "getListElements", HandleGetListCmd },
     { "getGlobalVariables", HandleGetGlobalsCmd },
     { "getScriptURLs", HandleGetScriptURLsCmd },
     { "getScriptSource", HandleGetSourceCmd },
     { "getStackTrace", HandleGetStackTraceCmd },
     { "setBreakpoint", HandleSetBpCmd },
     { "setPauseOnException", HandlePauseOnExcCmd },
     { "removeBreakpoint", HandleRemBpCmd },
     { "stepInto", HandleStepIntoCmd },
     { "stepOut", HandleStepOutCmd },
     { "stepOver", HandleStepOverCmd },
@@ skipping 157 matching lines @@
   DebuggerConnectionImpl::StartHandler(port_number);
   Dart_SetBreakpointHandler(BreakpointHandler);
   Dart_SetBreakpointResolvedHandler(BptResolvedHandler);
   Dart_SetExceptionThrownHandler(ExceptionThrownHandler);
 }
 
 
 DebuggerConnectionHandler::~DebuggerConnectionHandler() {
   CloseDbgConnection();
 }