Improve JSON stringifier's escape check.

src/scanner.h

 // Copyright 2011 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 154 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UnicodeCache);
 };
 
 
 // ----------------------------------------------------------------------------
 // LiteralBuffer -  Collector of chars of literals.
 
 class LiteralBuffer {
  public:
-  LiteralBuffer() : is_ascii_(true), position_(0), backing_store_() { }
+  // "Printable" ASCII is in the range 0x20 .. 0x7e.
+  enum CharacterRange { PRINTABLE_ASCII, ASCII, TWO_BYTE };
+
+  LiteralBuffer() : character_range_(PRINTABLE_ASCII),
+                    position_(0),
+                    backing_store_() { }
 
   ~LiteralBuffer() {
     if (backing_store_.length() > 0) {
       backing_store_.Dispose();
     }
   }
 
   INLINE(void AddChar(uint32_t code_unit)) {
     if (position_ >= backing_store_.length()) ExpandBuffer();
-    if (is_ascii_) {
-      if (code_unit <= unibrow::Latin1::kMaxChar) {
-        backing_store_[position_] = static_cast<byte>(code_unit);
-        position_ += kOneByteSize;
+    switch (character_range_) {
+      case PRINTABLE_ASCII:
+        if (code_unit >= 0x20 && code_unit < 0x7f) break;
+        character_range_ = ASCII;
+      case ASCII:
+        if (code_unit <= unibrow::Latin1::kMaxChar) break;
+        ConvertToUtf16();
+      case TWO_BYTE:
+        ASSERT(code_unit < 0x10000u);
+        *reinterpret_cast<uc16*>(&backing_store_[position_]) = code_unit;
+        position_ += kUC16Size;
         return;
-      }
-      ConvertToUtf16();
     }
-    ASSERT(code_unit < 0x10000u);
-    *reinterpret_cast<uc16*>(&backing_store_[position_]) = code_unit;
-    position_ += kUC16Size;
+    ASSERT(character_range_ <= ASCII);
+    backing_store_[position_] = static_cast<byte>(code_unit);
+    position_ += kOneByteSize;
   }
 
-  bool is_ascii() { return is_ascii_; }
+  inline bool is_ascii() { return character_range_ <= ASCII; }
+  bool is_printable_ascii() { return character_range_ == PRINTABLE_ASCII; }
 
   Vector<const uc16> utf16_literal() {
-    ASSERT(!is_ascii_);
+    ASSERT(character_range_ == TWO_BYTE);
     ASSERT((position_ & 0x1) == 0);
     return Vector<const uc16>(
         reinterpret_cast<const uc16*>(backing_store_.start()),
         position_ >> 1);
   }
 
   Vector<const char> ascii_literal() {
-    ASSERT(is_ascii_);
+    ASSERT(is_ascii());
     return Vector<const char>(
         reinterpret_cast<const char*>(backing_store_.start()),
         position_);
   }
 
   int length() {
-    return is_ascii_ ? position_ : (position_ >> 1);
+    return is_ascii() ? position_ : (position_ >> 1);
   }
 
   void Reset() {
     position_ = 0;
-    is_ascii_ = true;
+    character_range_ = PRINTABLE_ASCII;
   }
 
  private:
   static const int kInitialCapacity = 16;
   static const int kGrowthFactory = 4;
   static const int kMinConversionSlack = 256;
   static const int kMaxGrowth = 1 * MB;
   inline int NewCapacity(int min_capacity) {
     int capacity = Max(min_capacity, backing_store_.length());
     int new_capacity = Min(capacity * kGrowthFactory, capacity + kMaxGrowth);
     return new_capacity;
   }
 
   void ExpandBuffer() {
     Vector<byte> new_store = Vector<byte>::New(NewCapacity(kInitialCapacity));
     memcpy(new_store.start(), backing_store_.start(), position_);
     backing_store_.Dispose();
     backing_store_ = new_store;
   }
 
   void ConvertToUtf16() {
-    ASSERT(is_ascii_);
+    ASSERT(character_range_ == ASCII);
     Vector<byte> new_store;
     int new_content_size = position_ * kUC16Size;
     if (new_content_size >= backing_store_.length()) {
       // Ensure room for all currently read code units as UC16 as well
       // as the code unit about to be stored.
       new_store = Vector<byte>::New(NewCapacity(new_content_size));
     } else {
       new_store = backing_store_;
     }
     uint8_t* src = backing_store_.start();
     uc16* dst = reinterpret_cast<uc16*>(new_store.start());
     for (int i = position_ - 1; i >= 0; i--) {
       dst[i] = src[i];
     }
     if (new_store.start() != backing_store_.start()) {
       backing_store_.Dispose();
       backing_store_ = new_store;
     }
     position_ = new_content_size;
-    is_ascii_ = false;
+    character_range_ = TWO_BYTE;
   }
 
-  bool is_ascii_;
+  CharacterRange character_range_;
   int position_;
   Vector<byte> backing_store_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralBuffer);
 };
 
 
 // ----------------------------------------------------------------------------
 // JavaScript Scanner.
 
@@ skipping 60 matching lines @@
     return current_.literal_chars->ascii_literal();
   }
   Vector<const uc16> literal_utf16_string() {
     ASSERT_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->utf16_literal();
   }
   bool is_literal_ascii() {
     ASSERT_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->is_ascii();
   }
+  bool is_literal_printable_ascii() {
+    ASSERT_NOT_NULL(current_.literal_chars);
+    return current_.literal_chars->is_printable_ascii();
+  }
   int literal_length() const {
     ASSERT_NOT_NULL(current_.literal_chars);
     return current_.literal_chars->length();
   }
 
   bool literal_contains_escapes() const {
     Location location = current_.location;
     int source_length = (location.end_pos - location.beg_pos);
     if (current_.token == Token::STRING) {
       // Subtract delimiters.
@@ skipping 204 matching lines @@
   bool has_multiline_comment_before_next_;
   // Whether we scan 'let' as a keyword for harmony block-scoped let bindings.
   bool harmony_scoping_;
   // Whether we scan 'module', 'import', 'export' as keywords.
   bool harmony_modules_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_