Generate escape sequence for non-printable ascii characters

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 340 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);
+}
+
+
+static int32_t EscapeOverhead(int32_t c) {
+  if (IsSpecialCharacter(c)) {
+    return 1;  // 1 additional byte for the backslash.
+  } else if (IsAsciiNonprintable(c)) {
+    return 3;  // 3 additional bytes to encode c as \x00.
+  }
+  return 0;
+}
+
+
 template<typename type>
 static type SpecialCharacter(type value) {
   if (value == '"') {
     return '"';
   } else if (value == '\n') {
     return 'n';
   } else if (value == '\f') {
     return 'f';
   } else if (value == '\b') {
     return 'b';
@@ skipping 6717 matching lines @@
     obj = iterator.CurrentToken();
     literal = iterator.MakeLiteralToken(obj);
     // Advance to be able to use next token kind.
     iterator.Advance();
     Token::Kind next = iterator.CurrentTokenKind();
 
     // Handle the current token.
     if (curr == Token::kSTRING) {
       bool escape_characters = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
-        if (IsSpecialCharacter(literal.CharAt(i))) {
+        if (NeedsEscapeSequence(literal.CharAt(i))) {
           escape_characters = true;
         }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
         literals.Add(Symbols::DoubleQuotes());
       }
       if (escape_characters) {
         literal = String::EscapeSpecialCharacters(literal);
         literals.Add(literal);
       } else {
@@ skipping 9140 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 code_point) {
-  return code_point >= ' ' && code_point <= '~';
-}
-
-
 // Does not null-terminate.
 intptr_t String::EscapedString(char* buffer, int max_len) const {
   int pos = 0;
 
   CodePointIterator cpi(*this);
   while (cpi.Next()) {
     int32_t code_point = cpi.Current();
     if (IsSpecialCharacter(code_point)) {
       if (pos + 2 > max_len) {
         return pos;
@@ skipping 342 matching lines @@
   index_ = end_;
   return false;
 }
 
 
 RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        num_escapes += 1;
-      }
+      num_escapes += EscapeOverhead(*CharAddr(str, i));
     }
     const String& dststr = String::Handle(
         OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        *(CharAddr(dststr, index)) = '\\';
-        *(CharAddr(dststr, index + 1)) = SpecialCharacter(*CharAddr(str, i));
+      uint8_t ch = CharAt(str, i);
+      if (IsSpecialCharacter(ch)) {
+        SetCharAt(dststr, index, '\\');
+        SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
+      } else if (IsAsciiNonprintable(ch)) {
+        SetCharAt(dststr, index, '\\');
+        SetCharAt(dststr, index + 1, 'x');
+        SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
+        SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
+        index += 4;
       } else {
-        *(CharAddr(dststr, index)) = *CharAddr(str, i);
+        SetCharAt(dststr, index, ch);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::raw(Symbols::Empty());
 }
 
+
 RawOneByteString* ExternalOneByteString::EscapeSpecialCharacters(
     const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        num_escapes += 1;
-      }
+      num_escapes += EscapeOverhead(*CharAddr(str, i));
     }
     const String& dststr = String::Handle(
         OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        *(OneByteString::CharAddr(dststr, index)) = '\\';
-        *(OneByteString::CharAddr(dststr, index + 1)) =
-        SpecialCharacter(*CharAddr(str, i));
+      uint8_t ch = CharAt(str, i);
+      if (IsSpecialCharacter(ch)) {
+        OneByteString::SetCharAt(dststr, index, '\\');
+        OneByteString::SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
+      } else if (IsAsciiNonprintable(ch)) {
+        OneByteString::SetCharAt(dststr, index, '\\');
+        OneByteString::SetCharAt(dststr, index + 1, 'x');
+        OneByteString::SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
+        OneByteString::SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
+        index += 4;
       } else {
-        *(OneByteString::CharAddr(dststr, index)) = *CharAddr(str, i);
+        *(OneByteString::CharAddr(dststr, index)) = ch;
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::raw(Symbols::Empty());
 }
 
 
 RawOneByteString* OneByteString::New(intptr_t len,
@@ skipping 200 matching lines @@
                              void* peer) {
   delete reinterpret_cast<ExternalStringData<uint8_t>*>(peer);
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        num_escapes += 1;
-      }
+      num_escapes += EscapeOverhead(*CharAddr(str, i));
     }
     const String& dststr = String::Handle(
         TwoByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i))) {
-        *(CharAddr(dststr, index)) = '\\';
-        *(CharAddr(dststr, index + 1)) = SpecialCharacter(*CharAddr(str, i));
+      uint16_t ch = CharAt(str, i);
+      if (IsSpecialCharacter(ch)) {
+        SetCharAt(dststr, index, '\\');
+        SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
+      } else if (IsAsciiNonprintable(ch)) {
+        SetCharAt(dststr, index, '\\');
+        SetCharAt(dststr, index + 1, 'x');
+        SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
+        SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
+        index += 4;
       } else {
-        *(CharAddr(dststr, index)) = *CharAddr(str, i);
+        SetCharAt(dststr, index, ch);
         index += 1;
       }
     }
     return TwoByteString::raw(dststr);
   }
   return TwoByteString::New(0, Heap::kNew);
 }
 
 
 RawTwoByteString* TwoByteString::New(intptr_t len,
@@ skipping 1640 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart