- Add a test case to test Source code generation of all the corelibs

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/bigint_operations.h"
@@ skipping 172 matching lines @@
   if (is_setter) {
     // Setters need to end with '='.
     const String& suffix = String::Handle(Symbols::Equals());
     return String::Concat(result, suffix);
   }
 
   return result.raw();
 }
 
 
+template<typename type>
+static bool IsSpecialCharacter(type value) {
+  return ((value == '"') ||
+          (value == '\n') ||
+          (value == '\f') ||
+          (value == '\b') ||
+          (value == '\t') ||
+          (value == '\v') ||
+          (value == '\r'));
+}
+
+
+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';
+  } else if (value == '\t') {
+    return 't';
+  } else if (value == '\v') {
+    return 'v';
+  } else if (value == '\r') {
+    return 'r';
+  }
+  UNREACHABLE();
+  return '\0';
+}
+
+
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
@@ skipping 4830 matching lines @@
       GrowableObjectArray::Handle(GrowableObjectArray::New(data.Length()));
   const String& private_key = String::Handle(PrivateKey());
   intptr_t private_len = private_key.Length();
 
   String& blank = String::Handle(String::New(" "));
   String& newline = String::Handle(String::New("\n"));
   String& two_newlines = String::Handle(String::New("\n\n"));
   String& double_quotes = String::Handle(String::New("\""));
   String& dollar = String::Handle(String::New("$"));
   String& two_spaces = String::Handle(String::New("  "));
+  String& raw_string = String::Handle(String::New("@"));
 
   Token::Kind curr = iterator.CurrentTokenKind();
   Token::Kind prev = Token::kILLEGAL;
   // Handles used in the loop.
   Object& obj = Object::Handle();
   String& literal = String::Handle();
   // Current indentation level.
   int indent = 0;
 
   while (curr != Token::kEOS) {
     // Remember current values for this token.
     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_quotes = false;
+      bool is_raw_string = false;
+      bool escape_characters = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
-        if (literal.CharAt(i) == '"') {
-          escape_quotes = true;
-          break;
+        if (IsSpecialCharacter(literal.CharAt(i))) {
+          escape_characters = true;
+        }
+        // TODO(4995): Temp solution for raw strings, this will break

[Ivan Posva, 2012/09/09 10:24:17]

I see two different options here to fix this current workaround: Either
introduce a token kRAW_STRING or prepend a token AT before the string literal
token. Obviously both of these would need some extra handling in the parser.

[Ivan Posva, 2012/09/09 10:31:58]

Of course I had another idea just after hitting send which does not need changes
to the parser: Preserve the fact that the string was a raw string in the literal
token.

+        // if we saw a string that is not a raw string but has back slashes
+        // in it.
+        if ((literal.CharAt(i) == '\\')) {
+          if ((next != Token::kINTERPOL_VAR) &&
+              (next != Token::kINTERPOL_START) &&
+              (prev != Token::kINTERPOL_VAR) &&
+              (prev != Token::kINTERPOL_END)) {
+            is_raw_string = true;
+          } else {
+            escape_characters = true;
+          }
         }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
+        if (is_raw_string) {
+          literals.Add(raw_string);
+        }
         literals.Add(double_quotes);
       }
-      if (escape_quotes) {
-        literal = String::EscapeDoubleQuotes(literal);
+      if (escape_characters) {
+        literal = String::EscapeSpecialCharacters(literal, is_raw_string);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
         literals.Add(double_quotes);
       }
     } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(dollar);
+      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+        literal = String::SubString(literal, 0, literal.Length() - private_len);
+      }
       literals.Add(literal);
     } else if (curr == Token::kIDENT) {
       if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
@@ skipping 4315 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) {
+RawString* String::EscapeSpecialCharacters(const String& str, bool raw_str) {
   if (str.IsOneByteString()) {
     const OneByteString& onestr = OneByteString::Cast(str);
-    return onestr.EscapeDoubleQuotes();
+    return onestr.EscapeSpecialCharacters(raw_str);
   }
   if (str.IsTwoByteString()) {
     const TwoByteString& twostr = TwoByteString::Cast(str);
-    return twostr.EscapeDoubleQuotes();
+    return twostr.EscapeSpecialCharacters(raw_str);
   }
   ASSERT(str.IsFourByteString());
   const FourByteString& fourstr = FourByteString::Cast(str);
-  return fourstr.EscapeDoubleQuotes();
+  return fourstr.EscapeSpecialCharacters(raw_str);
 }
 
 
 RawString* String::NewFormatted(const char* format, ...) {
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   Zone* zone = Isolate::Current()->current_zone();
@@ skipping 147 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 {
+RawOneByteString* OneByteString::EscapeSpecialCharacters(bool raw_str) const {
   intptr_t len = Length();
   if (len > 0) {
-    intptr_t num_quotes = 0;
+    intptr_t num_escapes = 0;
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
-        num_quotes += 1;
+      if (IsSpecialCharacter(*CharAddr(i)) ||
+          (!raw_str && (*CharAddr(i) == '\\'))) {
+        num_escapes += 1;
       }
     }
     const OneByteString& dststr = OneByteString::Handle(
-        OneByteString::New(len + num_quotes, Heap::kNew));
+        OneByteString::New(len + num_escapes, Heap::kNew));
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
+      if (IsSpecialCharacter(*CharAddr(i))) {
         *(dststr.CharAddr(index)) = '\\';
-        *(dststr.CharAddr(index + 1)) = '"';
+        *(dststr.CharAddr(index + 1)) = SpecialCharacter(*CharAddr(i));
+        index += 2;
+      } else if (!raw_str && (*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();
 }
@@ skipping 162 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* OneByteString::ToCString() const {
   return String::ToCString();
 }
 
 
-RawTwoByteString* TwoByteString::EscapeDoubleQuotes() const {
+RawTwoByteString* TwoByteString::EscapeSpecialCharacters(bool raw_str) const {
   intptr_t len = Length();
   if (len > 0) {
-    intptr_t num_quotes = 0;
+    intptr_t num_escapes = 0;
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
-        num_quotes += 1;
+      if (IsSpecialCharacter(*CharAddr(i)) ||
+          (!raw_str && (*CharAddr(i) == '\\'))) {
+        num_escapes += 1;
       }
     }
     const TwoByteString& dststr = TwoByteString::Handle(
-        TwoByteString::New(len + num_quotes, Heap::kNew));
+        TwoByteString::New(len + num_escapes, Heap::kNew));
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
+      if (IsSpecialCharacter(*CharAddr(i))) {
         *(dststr.CharAddr(index)) = '\\';
-        *(dststr.CharAddr(index + 1)) = '"';
+        *(dststr.CharAddr(index + 1)) = SpecialCharacter(*CharAddr(i));
+        index += 2;
+      } else if (!raw_str && (*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();
 }
@@ skipping 96 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* TwoByteString::ToCString() const {
   return String::ToCString();
 }
 
 
-RawFourByteString* FourByteString::EscapeDoubleQuotes() const {
+RawFourByteString* FourByteString::EscapeSpecialCharacters(bool raw_str) const {
   intptr_t len = Length();
   if (len > 0) {
-    intptr_t num_quotes = 0;
+    intptr_t num_escapes = 0;
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
-        num_quotes += 1;
+      if (IsSpecialCharacter(*CharAddr(i)) ||
+          (!raw_str && (*CharAddr(i) == '\\'))) {
+        num_escapes += 1;
       }
     }
     const FourByteString& dststr = FourByteString::Handle(
-        FourByteString::New(len + num_quotes, Heap::kNew));
+        FourByteString::New(len + num_escapes, Heap::kNew));
     for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(i) == '"') {
+      if (IsSpecialCharacter(*CharAddr(i))) {
         *(dststr.CharAddr(index)) = '\\';
-        *(dststr.CharAddr(index + 1)) = '"';
+        *(dststr.CharAddr(index + 1)) = SpecialCharacter(*CharAddr(i));
+        index += 2;
+      } else if (!raw_str && (*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();
 }
@@ skipping 1461 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart