Translate raw strings to regular strings during source code generation. This should hopefully avoid…

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/bigint_operations.h"
@@ skipping 233 matching lines @@
 
 
 template<typename type>
 static bool IsSpecialCharacter(type value) {
   return ((value == '"') ||
           (value == '\n') ||
           (value == '\f') ||
           (value == '\b') ||
           (value == '\t') ||
           (value == '\v') ||
-          (value == '\r'));
+          (value == '\r') ||
+          (value == '\\') ||
+          (value == '$'));
 }
 
 
 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';
+  } else if (value == '\\') {
+    return '\\';
+  } else if (value == '$') {
+    return '$';
   }
   UNREACHABLE();
   return '\0';
 }
 
 
 static void DeleteWeakPersistentHandle(Dart_Handle handle) {
   ApiState* state = Isolate::Current()->api_state();
   ASSERT(state != NULL);
   FinalizablePersistentHandle* weak_ref =
@@ skipping 4553 matching lines @@
   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 is_raw_string = false;
       bool escape_characters = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
         if (IsSpecialCharacter(literal.CharAt(i))) {
           escape_characters = true;
         }
-        // TODO(4995): Temp solution for raw strings, this will break
-        // 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 ((literal.CharAt(i) == '$')) {
-          escape_characters = true;
-        }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
-        if (is_raw_string) {
-          literals.Add(Symbols::LowercaseR());
-        }
         literals.Add(Symbols::DoubleQuotes());
       }
       if (escape_characters) {
-        literal = String::EscapeSpecialCharacters(literal, is_raw_string);
+        literal = String::EscapeSpecialCharacters(literal);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
         literals.Add(Symbols::DoubleQuotes());
       }
     } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(Symbols::Dollar());
       if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
@@ skipping 6241 matching lines @@
         String::Copy(dst,
                      dst_offset,
                      ExternalTwoByteString::CharAddr(src, src_offset),
                      len);
       }
     }
   }
 }
 
 
-RawString* String::EscapeSpecialCharacters(const String& str, bool raw_str) {
+RawString* String::EscapeSpecialCharacters(const String& str) {
   if (str.IsOneByteString()) {
-    return OneByteString::EscapeSpecialCharacters(str, raw_str);
+    return OneByteString::EscapeSpecialCharacters(str);
   }
   ASSERT(str.IsTwoByteString());
-  return TwoByteString::EscapeSpecialCharacters(str, raw_str);
+  return TwoByteString::EscapeSpecialCharacters(str);
 }
 
 
 RawString* String::NewFormatted(const char* format, ...) {
   va_list args;
   va_start(args, format);
   RawString* result = NewFormattedV(format, args);
   NoGCScope no_gc;
   va_end(args);
   return result;
@@ skipping 367 matching lines @@
         ch_ = Utf16::Decode(ch_, ch2);
       }
     }
     return true;
   }
   index_ = end_;
   return false;
 }
 
 
-RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str,
-                                                         bool raw_str) {
+RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i)) ||
-          (!raw_str && (*CharAddr(str, i) == '$')) ||
-          (!raw_str && (*CharAddr(str, i) == '\\'))) {
+      if (IsSpecialCharacter(*CharAddr(str, i))) {
         num_escapes += 1;
       }
     }
     const String& dststr = String::Handle(
         OneByteString::New(len + num_escapes, Heap::kNew));
     for (intptr_t i = 0; i < len; i++) {
       if (IsSpecialCharacter(*CharAddr(str, i))) {
         *(CharAddr(dststr, index)) = '\\';
         *(CharAddr(dststr, index + 1)) = SpecialCharacter(*CharAddr(str, i));
         index += 2;
-      } else if (!raw_str && (*CharAddr(str, i) == '$')) {
-        *(CharAddr(dststr, index)) = '\\';
-        *(CharAddr(dststr, index + 1)) = '$';
-        index += 2;
-      } else if (!raw_str && (*CharAddr(str, i) == '\\')) {
-        *(CharAddr(dststr, index)) = '\\';
-        *(CharAddr(dststr, index + 1)) = '\\';
-        index += 2;
       } else {
         *(CharAddr(dststr, index)) = *CharAddr(str, i);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::null();
 }
 
@@ skipping 141 matching lines @@
   NoGCScope no_gc;
   if (length > 0) {
     uint8_t* dest = &result->ptr()->data_[0];
     uint8_t* src =  &raw_ptr(str)->data_[begin_index];
     memmove(dest, src, length);
   }
   return result;
 }
 
 
-RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str,
-                                                         bool raw_str) {
+RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
-      if (IsSpecialCharacter(*CharAddr(str, i)) ||
-          (!raw_str && (*CharAddr(str, i) == '\\'))) {
+      if (IsSpecialCharacter(*CharAddr(str, i))) {
         num_escapes += 1;
       }
     }
     const String& dststr = String::Handle(
         TwoByteString::New(len + num_escapes, Heap::kNew));
     for (intptr_t i = 0; i < len; i++) {
       if (IsSpecialCharacter(*CharAddr(str, i))) {
         *(CharAddr(dststr, index)) = '\\';
         *(CharAddr(dststr, index + 1)) = SpecialCharacter(*CharAddr(str, i));
         index += 2;
-      } else if (!raw_str && (*CharAddr(str, i) == '\\')) {
-        *(CharAddr(dststr, index)) = '\\';
-        *(CharAddr(dststr, index + 1)) = '\\';
-        index += 2;
       } else {
         *(CharAddr(dststr, index)) = *CharAddr(str, i);
         index += 1;
       }
     }
     return TwoByteString::raw(dststr);
   }
   return TwoByteString::null();
 }
 
@@ skipping 1750 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart