Add Instance::ToUserCString.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 11375 matching lines @@
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
-    const String& type_name = String::Handle(type.Name());
+    const String& type_name = String::Handle(type.UserVisibleName());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
+const char* Instance::ToUserCString(intptr_t maxLen) const {
+  if (raw() == Object::sentinel().raw()) {
+    return "<not initialized>";
+  } else if (raw() == Object::transition_sentinel().raw()) {
+    return "<being initialized>";
+  } else {
+    return ToCString();
+  }
+}
+
+
 void Instance::PrintToJSONStream(JSONStream* stream, bool ref) const {
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   intptr_t id = ring->GetIdForObject(raw());
 
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddProperty("id", id);
 
   // Set the "preview" property for this instance.
   if (IsNull()) {
@@ skipping 2801 matching lines @@
   }
   const intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<const char*>(result);
 }
 
 
+static bool IsAsciiPrintChar(intptr_t codePoint) {
+  return codePoint >= ' ' && codePoint <= '~';
+}
+
+
+// Does not null-terminate.
+intptr_t String::EscapedString(char* buffer, int maxLen) const {
+  int pos = 0;
+
+  CodePointIterator cpi(*this);
+  while (cpi.Next()) {
+    int32_t codePoint = cpi.Current();
+    if (IsSpecialCharacter(codePoint)) {
+      if (pos + 2 > maxLen) {
+        return pos;
+      }
+      buffer[pos++] = '\\';
+      buffer[pos++] = SpecialCharacter(codePoint);
+    } else if (IsAsciiPrintChar(codePoint)) {
+      buffer[pos++] = codePoint;
+    } else {
+      if (pos + 6 > maxLen) {
+        return pos;
+      }
+      pos += OS::SNPrint((buffer + pos), (maxLen - pos), "\\u%04x", codePoint);
+    }
+    if (pos == maxLen) {
+      return pos;
+    }
+  }
+  return pos;
+}
+
+
+intptr_t String::EscapedStringLen(intptr_t tooLong) const {
+  intptr_t len = 0;
+
+  CodePointIterator cpi(*this);
+  while (cpi.Next()) {
+    int32_t codePoint = cpi.Current();
+    if (IsSpecialCharacter(codePoint)) {
+      len += 2;  // e.g. "\n"
+    } else if (IsAsciiPrintChar(codePoint)) {
+      len += 1;
+    } else {
+      len += 6;  // e.g. "\u0000".
+    }
+    if (len > tooLong) {
+      // No point going further.
+      break;
+    }
+  }
+  return len;
+}
+
+
+const char* String::ToUserCString(intptr_t maxLen) const {
+  // Compute the needed length for the buffer.
+  const intptr_t escapedLen = EscapedStringLen(maxLen);
+  intptr_t printLen = escapedLen;
+  intptr_t bufferLen = escapedLen + 2;  // +2 for quotes.
+  if (bufferLen > maxLen) {
+    bufferLen = maxLen;     // Truncate.
+    printLen = maxLen - 5;  // -2 for quotes, -3 for elipsis.
+  }
+
+  // Allocate the buffer.
+  Zone* zone = Isolate::Current()->current_zone();
+  char* buffer = zone->Alloc<char>(bufferLen + 1);
+
+  // Leading quote.
+  intptr_t pos = 0;
+  buffer[pos++] = '\"';
+
+  // Print escaped string.
+  pos += EscapedString((buffer + pos), printLen);
+
+  // Trailing quote.
+  buffer[pos++] = '\"';
+
+  if (printLen < escapedLen) {
+    buffer[pos++] = '.';
+    buffer[pos++] = '.';
+    buffer[pos++] = '.';
+  }
+  ASSERT(pos <= bufferLen);
+  buffer[pos++] = '\0';
+
+  return buffer;
+}
+
+
 void String::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
   ASSERT(array_len >= Utf8::Length(*this));
   Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
 }
 
@@ skipping 1028 matching lines @@
     result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
     return "_GrowableList NULL";
   }
-  const char* format = "_GrowableList len:%" Pd "";
+  const char* format = "Instance(length:%" Pd ") of '_GrowableList'";
   intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, Length());
   return chars;
 }
 
 
 void GrowableObjectArray::PrintToJSONStream(JSONStream* stream,
                                             bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
@@ skipping 769 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart