Don't double-escape in strings in the VM Service, and don't use \u0000 to determine the string lengt

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 346 matching lines @@
           (value == '\f') ||
           (value == '\b') ||
           (value == '\t') ||
           (value == '\v') ||
           (value == '\r') ||
           (value == '\\') ||
           (value == '$'));
 }
 
 
-static bool IsAsciiPrintChar(int32_t code_point) {
-  return (code_point >= ' ') && (code_point <= '~');
-}
-
-
 static inline bool IsAsciiNonprintable(int32_t c) {
   return ((0 <= c) && (c < 32)) || (c == 127);
 }
 
 
 static inline bool NeedsEscapeSequence(int32_t c) {
   return (c == '"')  ||
          (c == '\\') ||
          (c == '$')  ||
          IsAsciiNonprintable(c);
@@ skipping 16660 matching lines @@
     result = OneByteString::New(length, space);
   } else {
     result = TwoByteString::New(length, space);
   }
   String::Copy(result, 0, str, begin_index, length);
   return result.raw();
 }
 
 
 const char* String::ToCString() const {
+  intptr_t length;
+  return ToCString(&length);
+}
+
+
+const char* String::ToCString(intptr_t* length) const {
   if (IsOneByteString()) {
     // Quick conversion if OneByteString contains only ASCII characters.
     intptr_t len = Length();
     if (len == 0) {
+      *length = 0;
       return "";
     }
     Zone* zone = Isolate::Current()->current_zone();
     uint8_t* result = zone->Alloc<uint8_t>(len + 1);
     NoGCScope no_gc;
     const uint8_t* original_str = OneByteString::CharAddr(*this, 0);
     for (intptr_t i = 0; i < len; i++) {
       if (original_str[i] <= Utf8::kMaxOneByteChar) {
         result[i] = original_str[i];
       } else {
         len = -1;
         break;
       }
     }
     if (len > 0) {
       result[len] = 0;
+      *length = len;
       return reinterpret_cast<const char*>(result);
     }
   }
   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;
+  *length = len;
   return reinterpret_cast<const char*>(result);
 }
 
 
-// Does not null-terminate.
-intptr_t String::EscapedString(char* buffer, int max_len) const {
-  int pos = 0;
+const char* String::ToCStringTruncated(intptr_t max_len,
+                                       bool* did_truncate,
+                                       intptr_t* length) const {
+  if (Length() <= max_len) {
+    *did_truncate = false;
+    return ToCString(length);
+  }
 
-  CodePointIterator cpi(*this);
-  while (cpi.Next()) {
-    int32_t code_point = cpi.Current();
-    if (IsSpecialCharacter(code_point)) {
-      if (pos + 2 > max_len) {
-        return pos;
-      }
-      buffer[pos++] = '\\';
-      buffer[pos++] = SpecialCharacter(code_point);
-    } else if (IsAsciiPrintChar(code_point)) {
-      buffer[pos++] = code_point;
-    } else {
-      if (pos + 6 > max_len) {
-        return pos;
-      }
-      pos += OS::SNPrint((buffer + pos), (max_len - pos),
-                         "\\u%04x", code_point);
-    }
-    if (pos == max_len) {
-      return pos;
-    }
+  intptr_t aligned_limit = max_len;
+  if (Utf16::IsLeadSurrogate(CharAt(max_len - 1))) {
+    // Don't let truncation split a surrogate pair.
+    aligned_limit--;
   }
-  return pos;
+  ASSERT(!Utf16::IsLeadSurrogate(CharAt(aligned_limit - 1)));
+
+  *did_truncate = true;
+  const String& truncated =
+      String::Handle(String::SubString(*this, 0, aligned_limit));
+  return truncated.ToCString(length);
 }
 
 
-intptr_t String::EscapedStringLen(intptr_t too_long) const {
-  intptr_t len = 0;
-
-  CodePointIterator cpi(*this);
-  while (cpi.Next()) {
-    int32_t code_point = cpi.Current();
-    if (IsSpecialCharacter(code_point)) {
-      len += 2;  // e.g. "\n"
-    } else if (IsAsciiPrintChar(code_point)) {
-      len += 1;
-    } else {
-      len += 6;  // e.g. "\u0000".
-    }
-    if (len > too_long) {
-      // No point going further.
-      break;
-    }
-  }
-  return len;
-}
-
-
-const char* String::ToUserCString(intptr_t max_len) const {
-  // Compute the needed length for the buffer.
-  const intptr_t escaped_len = EscapedStringLen(max_len);
-  intptr_t print_len = escaped_len;
-  intptr_t buffer_len = escaped_len + 2;  // +2 for quotes.
-  if (buffer_len > max_len) {
-    buffer_len = max_len;     // Truncate.
-    print_len = max_len - 5;  // -2 for quotes, -3 for elipsis.
-  }
-
-  // Allocate the buffer.
-  Zone* zone = Isolate::Current()->current_zone();
-  char* buffer = zone->Alloc<char>(buffer_len + 1);
-
-  // Leading quote.
-  intptr_t pos = 0;
-  buffer[pos++] = '\"';
-
-  // Print escaped string.
-  pos += EscapedString((buffer + pos), print_len);
-
-  // Trailing quote.
-  buffer[pos++] = '\"';
-
-  if (print_len < escaped_len) {
-    buffer[pos++] = '.';
-    buffer[pos++] = '.';
-    buffer[pos++] = '.';
-  }
-  ASSERT(pos <= buffer_len);
-  buffer[pos++] = '\0';
-
-  return buffer;
-}
-
-
 void String::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if (raw() == Symbols::OptimizedOut().raw()) {
     // TODO(turnidge): This is a hack.  The user could have this
     // special string in their program.  Fixing this involves updating
     // the debugging api a bit.
     jsobj.AddProperty("type", "Sentinel");
     jsobj.AddProperty("id", "objects/optimized-out");
     jsobj.AddProperty("valueAsString", "<optimized out>");
     return;
   }
   PrintSharedInstanceJSON(&jsobj, ref);
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
-  jsobj.AddProperty("valueAsString", ToUserCString(1024));
+  if (ref) {
+    bool did_truncate = false;
+    intptr_t length = 0;

[turnidge, 2014/09/09 16:12:31]

Do you like these names?  I've always felt 'valueAsString' was a bit long, but
at least it is descriptive.  Do you have any other suggestions?

[rmacnak, 2014/09/09 21:00:23]

I'm not fond of them. Perhaps just 'toString'?

+    const char* cstr = ToCStringTruncated(128, &did_truncate, &length);
+    jsobj.AddProperty("valueAsString", cstr, length);
+    jsobj.AddProperty("valueAsStringIsTruncated", did_truncate);

[turnidge, 2014/09/09 16:12:31]

I think we should have a convention that if "valueAsStringIsTruncated" is false,
it is omitted.

This will make String valueAsString consistent with int valueAsString, which
currently doesn't provide a valueAsStringIsTruncated property.

[rmacnak, 2014/09/09 21:00:23]

I like that.

+  } else {
+    intptr_t length = 0;
+    const char* cstr = ToCString(&length);
+    jsobj.AddProperty("valueAsString", cstr, length);
+    jsobj.AddProperty("valueAsStringIsTruncated", false);
+  }
 }
 
 
 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);
 }
 
 
 static FinalizablePersistentHandle* AddFinalizer(
@@ skipping 2490 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart