Add quotes around strings when generating source from the token stream.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 4438 matching lines @@
   }
 }
 
 
 RawString* TokenStream::GenerateSource() const {
   GrowableObjectArray& literals =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Length()));
   String& literal = String::Handle();
   String& blank = String::Handle(String::New(" "));
   String& newline = String::Handle(String::New("\n"));
+  String& double_quotes = String::Handle(String::New("\""));
   for (intptr_t i = 0; i < Length(); i++) {
     Token::Kind kind = KindAt(i);
     literal = LiteralAt(i);
-    literals.Add(literal);
+    if (kind == Token::kSTRING) {
+      bool escape_quotes = false;
+      for (intptr_t i = 0; i < literal.Length(); i++) {
+        if (literal.CharAt(i) == '"') {
+          escape_quotes = true;
+          break;
+        }
+      }
+      literals.Add(double_quotes);
+      if (escape_quotes) {
+        literal = String::EscapeDoubleQuotes(literal);
+        literals.Add(literal);
+      } else {
+        literals.Add(literal);
+      }
+      literals.Add(double_quotes);
+    } else {
+      literals.Add(literal);
+    }
     if (kind == Token::kLBRACE) {
       literals.Add(newline);
     } else {
       literals.Add(blank);
     }
   }
   const Array& source = Array::Handle(Array::MakeArray(literals));
   return String::ConcatAll(source);
 }
 
@@ skipping 3831 matching lines @@
         const ExternalFourByteString& fourstr =
             ExternalFourByteString::Cast(src);
         NoGCScope no_gc;
         String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
       }
     }
   }
 }
 
 
+RawString* String::EscapeDoubleQuotes(const String& str) {
+  if (str.IsOneByteString()) {
+    const OneByteString& onestr = OneByteString::Cast(str);
+    return onestr.EscapeDoubleQuotes();
+  }
+  if (str.IsTwoByteString()) {
+    const TwoByteString& twostr = TwoByteString::Cast(str);
+    return twostr.EscapeDoubleQuotes();
+  }
+  ASSERT(str.IsFourByteString());
+  const FourByteString& fourstr = FourByteString::Cast(str);
+  return fourstr.EscapeDoubleQuotes();
+}
+
+
 static void GrowSymbolTable(const Array& symbol_table, intptr_t table_size) {
   // TODO(iposva): Avoid exponential growth.
   intptr_t new_table_size = table_size * 2;
   Array& new_symbol_table = Array::Handle(Array::New(new_table_size + 1));
   // Copy all elements from the original symbol table to the newly allocated
   // array.
   String& element = String::Handle();
   Object& new_element = Object::Handle();
   for (intptr_t i = 0; i < table_size; i++) {
     element ^= symbol_table.At(i);
@@ skipping 297 matching lines @@
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 
+RawOneByteString* OneByteString::EscapeDoubleQuotes() const {
+  intptr_t len = Length();
+  if (len > 0) {
+    intptr_t num_quotes = 0;
+    intptr_t index = 0;
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        num_quotes += 1;
+      }
+    }
+    const OneByteString& dststr = OneByteString::Handle(
+        OneByteString::New(len + num_quotes, Heap::kNew));
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        *(dststr.CharAddr(index)) = '\\';
+        *(dststr.CharAddr(index + 1)) = '"';
+        index += 2;
+      } else {
+        *(dststr.CharAddr(index)) = *CharAddr(i);
+        index += 1;
+      }
+    }
+    return dststr.raw();
+  }
+  return OneByteString::null();
+}
+
+
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->one_byte_string_class());
   OneByteString& result = OneByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       OneByteString::InstanceSize(len),
@@ skipping 93 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* OneByteString::ToCString() const {
   return String::ToCString();
 }
 
 
+RawTwoByteString* TwoByteString::EscapeDoubleQuotes() const {
+  intptr_t len = Length();
+  if (len > 0) {
+    intptr_t num_quotes = 0;
+    intptr_t index = 0;
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        num_quotes += 1;
+      }
+    }
+    const TwoByteString& dststr = TwoByteString::Handle(
+        TwoByteString::New(len + num_quotes, Heap::kNew));
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        *(dststr.CharAddr(index)) = '\\';
+        *(dststr.CharAddr(index + 1)) = '"';
+        index += 2;
+      } else {
+        *(dststr.CharAddr(index)) = *CharAddr(i);
+        index += 1;
+      }
+    }
+    return dststr.raw();
+  }
+  return TwoByteString::null();
+}
+
+
 RawTwoByteString* TwoByteString::New(intptr_t len,
                                      Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->two_byte_string_class());
   TwoByteString& result = TwoByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       TwoByteString::InstanceSize(len),
@@ skipping 83 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TwoByteString::ToCString() const {
   return String::ToCString();
 }
 
 
+RawFourByteString* FourByteString::EscapeDoubleQuotes() const {
+  intptr_t len = Length();
+  if (len > 0) {
+    intptr_t num_quotes = 0;
+    intptr_t index = 0;
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        num_quotes += 1;
+      }
+    }
+    const FourByteString& dststr = FourByteString::Handle(
+        FourByteString::New(len + num_quotes, Heap::kNew));
+    for (intptr_t i = 0; i < len; i++) {
+      if (*CharAddr(i) == '"') {
+        *(dststr.CharAddr(index)) = '\\';
+        *(dststr.CharAddr(index + 1)) = '"';
+        index += 2;
+      } else {
+        *(dststr.CharAddr(index)) = *CharAddr(i);
+        index += 1;
+      }
+    }
+    return dststr.raw();
+  }
+  return FourByteString::null();
+}
+
+
 RawFourByteString* FourByteString::New(intptr_t len,
                                        Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->four_byte_string_class());
   FourByteString& result = FourByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       FourByteString::InstanceSize(len),
@@ skipping 1389 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart