Improve JSON stringifier's escape check.

src/json-stringifier.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 36 matching lines @@
   static const int kPartLengthGrowthFactor = 2;
 
   enum Result { UNCHANGED, SUCCESS, EXCEPTION, CIRCULAR, STACK_OVERFLOW };
 
   void Extend();
 
   void ChangeEncoding();
 
   void ShrinkCurrentPart();
 
-  template <bool is_ascii, typename Char>
+  template <bool ascii_mode, typename Char>
   INLINE(void Append_(Char c));
 
-  template <bool is_ascii, typename Char>
+  template <bool ascii_mode, typename Char>
   INLINE(void Append_(const Char* chars));
 
   INLINE(void Append(uint8_t c)) {
-    if (is_ascii_) {
+    if (ascii_mode_) {
       Append_<true>(c);
     } else {
       Append_<false>(c);
     }
   }
 
   INLINE(void AppendAscii(const char* chars)) {
-    if (is_ascii_) {
+    if (ascii_mode_) {
       Append_<true>(reinterpret_cast<const uint8_t*>(chars));
     } else {
       Append_<false>(reinterpret_cast<const uint8_t*>(chars));
     }
   }
 
   Handle<Object> ApplyToJsonFunction(Handle<Object> object,
                                      Handle<Object> key);
 
   Result SerializeGeneric(Handle<Object> object,
@@ skipping 40 matching lines @@
 
   Result SerializeJSValue(Handle<JSValue> object);
 
   INLINE(Result SerializeJSArray(Handle<JSArray> object));
   INLINE(Result SerializeJSObject(Handle<JSObject> object));
 
   Result SerializeJSArraySlow(Handle<JSArray> object, int length);
 
   void SerializeString(Handle<String> object);
 
-  template <typename SrcChar, typename DestChar>
+  template <bool printable_ascii_only, typename SrcChar, typename DestChar>
   INLINE(void SerializeStringUnchecked_(const SrcChar* src,
                                         DestChar* dest,
                                         int length));
 
-  template <bool is_ascii, typename Char>
+  template <bool printable_ascii_only, bool ascii_mode, typename Char>
   INLINE(void SerializeString_(Handle<String> string));
 
-  template <typename Char>
+  template <bool printable_ascii_only, typename Char>
   INLINE(bool DoNotEscape(Char c));
 
   template <typename Char>
   INLINE(Vector<const Char> GetCharVector(Handle<String> string));
 
   Result StackPush(Handle<Object> object);
   void StackPop();
 
   INLINE(Handle<String> accumulator()) {
     return Handle<String>(String::cast(accumulator_store_->value()), isolate_);
   }
 
   INLINE(void set_accumulator(Handle<String> string)) {
     return accumulator_store_->set_value(*string);
   }
 
   Isolate* isolate_;
   Factory* factory_;
   // We use a value wrapper for the string accumulator to keep the
   // (indirect) handle to it in the outermost handle scope.
   Handle<JSValue> accumulator_store_;
   Handle<String> current_part_;
   Handle<String> tojson_symbol_;
   Handle<JSArray> stack_;
   int current_index_;
   int part_length_;
-  bool is_ascii_;
+  bool ascii_mode_;
 
   static const int kJsonEscapeTableEntrySize = 8;
   static const char* const JsonEscapeTable;
 };
 
 
 // Translation table to escape ASCII characters.
 // Table entries start at a multiple of 8 and are null-terminated.
 const char* const BasicJsonStringifier::JsonEscapeTable =
     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
@@ skipping 24 matching lines @@
     "d\0      e\0      f\0      g\0      "
     "h\0      i\0      j\0      k\0      "
     "l\0      m\0      n\0      o\0      "
     "p\0      q\0      r\0      s\0      "
     "t\0      u\0      v\0      w\0      "
     "x\0      y\0      z\0      {\0      "
     "|\0      }\0      ~\0      \177\0      ";
 
 
 BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
-    : isolate_(isolate), current_index_(0), is_ascii_(true) {
+    : isolate_(isolate), current_index_(0), ascii_mode_(true) {
   factory_ = isolate_->factory();
   accumulator_store_ = Handle<JSValue>::cast(
                            factory_->ToObject(factory_->empty_string()));
   part_length_ = kInitialPartLength;
   current_part_ = factory_->NewRawOneByteString(kInitialPartLength);
   tojson_symbol_ =
       factory_->LookupOneByteSymbol(STATIC_ASCII_VECTOR("toJSON"));
   stack_ = factory_->NewJSArray(8);
 }
 
 
 MaybeObject* BasicJsonStringifier::Stringify(Handle<Object> object) {
   switch (SerializeObject(object)) {
     case UNCHANGED:
       return isolate_->heap()->undefined_value();
     case SUCCESS:
       ShrinkCurrentPart();
       return *factory_->NewConsString(accumulator(), current_part_);
     case CIRCULAR:
       return isolate_->Throw(*factory_->NewTypeError(
                  "circular_structure", HandleVector<Object>(NULL, 0)));
     case STACK_OVERFLOW:
       return isolate_->StackOverflow();
     default:
       return Failure::Exception();
   }
 }
 
 
-template <bool is_ascii, typename Char>
+template <bool ascii_mode, typename Char>
 void BasicJsonStringifier::Append_(Char c) {
-  if (is_ascii) {
+  if (ascii_mode) {
     SeqOneByteString::cast(*current_part_)->SeqOneByteStringSet(
         current_index_++, c);
   } else {
     SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet(
         current_index_++, c);
   }
   if (current_index_ == part_length_) Extend();
 }
 
 
-template <bool is_ascii, typename Char>
+template <bool ascii_mode, typename Char>
 void BasicJsonStringifier::Append_(const Char* chars) {
-  for ( ; *chars != '\0'; chars++) Append_<is_ascii, Char>(*chars);
+  for ( ; *chars != '\0'; chars++) Append_<ascii_mode, Char>(*chars);
 }
 
 
 Handle<Object> BasicJsonStringifier::ApplyToJsonFunction(
     Handle<Object> object, Handle<Object> key) {
   LookupResult lookup(isolate_);
   JSObject::cast(*object)->LookupRealNamedProperty(*tojson_symbol_, &lookup);
   if (!lookup.IsProperty()) return object;
   PropertyAttributes attr;
   Handle<Object> fun =
@@ skipping 332 matching lines @@
   current_part_ = Handle<String>(
       SeqString::cast(*current_part_)->Truncate(current_index_), isolate_);
 }
 
 
 void BasicJsonStringifier::Extend() {
   set_accumulator(factory_->NewConsString(accumulator(), current_part_));
   if (part_length_ <= kMaxPartLength / kPartLengthGrowthFactor) {
     part_length_ *= kPartLengthGrowthFactor;
   }
-  if (is_ascii_) {
+  if (ascii_mode_) {
     current_part_ = factory_->NewRawOneByteString(part_length_);
   } else {
     current_part_ = factory_->NewRawTwoByteString(part_length_);
   }
   current_index_ = 0;
 }
 
 
 void BasicJsonStringifier::ChangeEncoding() {
   ShrinkCurrentPart();
   set_accumulator(factory_->NewConsString(accumulator(), current_part_));
   current_part_ = factory_->NewRawTwoByteString(part_length_);
   current_index_ = 0;
-  is_ascii_ = false;
+  ascii_mode_ = false;
 }
 
 
-template <typename SrcChar, typename DestChar>
+template < bool printable_ascii_only, typename SrcChar, typename DestChar>
 void BasicJsonStringifier::SerializeStringUnchecked_(const SrcChar* src,
                                                      DestChar* dest,
                                                      int length) {
   dest += current_index_;
   DestChar* dest_start = dest;
 
   // Assert that uc16 character is not truncated down to 8 bit.
   // The <uc16, char> version of this method must not be called.
   ASSERT(sizeof(*dest) >= sizeof(*src));
 
   for (int i = 0; i < length; i++) {
     SrcChar c = src[i];
-    if (DoNotEscape(c)) {
+    if (DoNotEscape<printable_ascii_only>(c)) {
       *(dest++) = static_cast<DestChar>(c);
     } else {
       const char* chars = &JsonEscapeTable[c * kJsonEscapeTableEntrySize];
       while (*chars != '\0') *(dest++) = *(chars++);
     }
   }
 
   current_index_ += static_cast<int>(dest - dest_start);
 }
 
 
-template <bool is_ascii, typename Char>
+template <bool printable_ascii_only, bool ascii_mode, typename Char>
 void BasicJsonStringifier::SerializeString_(Handle<String> string) {
   int length = string->length();
-  Append_<is_ascii, char>('"');
+  Append_<ascii_mode, char>('"');
   // We make a rough estimate to find out if the current string can be
   // serialized without allocating a new string part. The worst case length of
   // an escaped character is 6.  Shifting the remainin string length right by 3
   // is a more pessimistic estimate, but faster to calculate.
 
   if (((part_length_ - current_index_) >> 3) > length) {
     AssertNoAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
-    if (is_ascii) {
-      SerializeStringUnchecked_(
+    if (ascii_mode) {
+      SerializeStringUnchecked_<printable_ascii_only>(
           vector.start(),
           SeqOneByteString::cast(*current_part_)->GetChars(),
           length);
     } else {
-      SerializeStringUnchecked_(
+      SerializeStringUnchecked_<printable_ascii_only>(
           vector.start(),
           SeqTwoByteString::cast(*current_part_)->GetChars(),
           length);
     }
   } else {
     String* string_location = *string;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = 0; i < length; i++) {
       Char c = vector[i];
-      if (DoNotEscape(c)) {
-        Append_<is_ascii, Char>(c);
+      if (DoNotEscape<printable_ascii_only>(c)) {
+        Append_<ascii_mode, Char>(c);
       } else {
-        Append_<is_ascii, uint8_t>(
+        Append_<ascii_mode, uint8_t>(
             reinterpret_cast<const uint8_t*>(
                 &JsonEscapeTable[c * kJsonEscapeTableEntrySize]));
       }
       // If GC moved the string, we need to refresh the vector.
       if (*string != string_location) {
         vector = GetCharVector<Char>(string);
         string_location = *string;
       }
     }
   }
 
-  Append_<is_ascii, uint8_t>('"');
+  Append_<ascii_mode, uint8_t>('"');
 }
 
 
-template <typename Char>
+template <bool printable_ascii_only, typename Char>
 bool BasicJsonStringifier::DoNotEscape(Char c) {
-  return (c >= 0x80) || (c >= '#' && c <= '~' && c != '\\');
+  // "Printable" ASCII is in the range 0x20 .. 0x7e.
+  return (c != '"' && c != '\\') &&
+         (printable_ascii_only || (c != 0x7f && c >= 0x20));
 }
 
 
 template <>
 Vector<const uint8_t> BasicJsonStringifier::GetCharVector(
     Handle<String> string) {
   String::FlatContent flat = string->GetFlatContent();
   ASSERT(flat.IsAscii());
   return flat.ToOneByteVector();
 }
 
 
 template <>
 Vector<const uc16> BasicJsonStringifier::GetCharVector(Handle<String> string) {
   String::FlatContent flat = string->GetFlatContent();
   ASSERT(flat.IsTwoByte());
   return flat.ToUC16Vector();
 }
 
 
 void BasicJsonStringifier::SerializeString(Handle<String> object) {
   FlattenString(object);
   String::FlatContent flat = object->GetFlatContent();
-  if (is_ascii_) {
+  if (ascii_mode_) {
     if (flat.IsAscii()) {
-      SerializeString_<true, uint8_t>(object);
+      if (object->map() == isolate_->heap()->printable_ascii_symbol_map()) {
+        SerializeString_<true, true, uint8_t>(object);
+      } else {
+        SerializeString_<false, true, uint8_t>(object);
+      }
     } else {
       ChangeEncoding();
       SerializeString(object);
     }
   } else {
     if (flat.IsAscii()) {
-      SerializeString_<false, uint8_t>(object);
+      if (object->map() == isolate_->heap()->printable_ascii_symbol_map()) {
+        SerializeString_<true, false, uint8_t>(object);
+      } else {
+        SerializeString_<false, false, uint8_t>(object);
+      }
     } else {
-      SerializeString_<false, uc16>(object);
+      SerializeString_<false, false, uc16>(object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_