Revert OneByteString back to ISO Latin-1 instead of ASCII

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 10049 matching lines @@
   const uint8_t* utf8_array = reinterpret_cast<const uint8_t*>(str);
   return String::New(utf8_array, array_len, space);
 }
 
 
 RawString* String::New(const uint8_t* utf8_array,
                        intptr_t array_len,
                        Heap::Space space) {
   Utf8::Type type;
   intptr_t len = Utf8::CodePointCount(utf8_array, array_len, &type);
-  if (type == Utf8::kAscii) {
+  if (type == Utf8::kLatin1) {
     const String& strobj = String::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoGCScope no_gc;
-      Utf8::DecodeToAscii(utf8_array, array_len,
-                          OneByteString::CharAddr(strobj, 0), len);
+      Utf8::DecodeToLatin1(utf8_array, array_len,
+                           OneByteString::CharAddr(strobj, 0), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSMP));
   const String& strobj = String::Handle(TwoByteString::New(len, space));
   NoGCScope no_gc;
   Utf8::DecodeToUTF16(utf8_array, array_len,
                       TwoByteString::CharAddr(strobj, 0), len);
   return strobj.raw();
 }
 
 
 RawString* String::New(const uint16_t* utf16_array,
                        intptr_t array_len,
                        Heap::Space space) {
   bool is_one_byte_string = true;
   for (intptr_t i = 0; i < array_len; ++i) {
-    if (utf16_array[i] > 0x7F) {
+    if (utf16_array[i] > 0xFF) {
       is_one_byte_string = false;
       break;
     }
   }
   if (is_one_byte_string) {
     return OneByteString::New(utf16_array, array_len, space);
   }
   return TwoByteString::New(utf16_array, array_len, space);
 }
 
 
 RawString* String::New(const uint32_t* utf32_array,
                        intptr_t array_len,
                        Heap::Space space) {
   bool is_one_byte_string = true;
   intptr_t utf16_len = array_len;
   for (intptr_t i = 0; i < array_len; ++i) {
-    if (utf32_array[i] > 0x7F) {
+    if (utf32_array[i] > 0xFF) {
       is_one_byte_string = false;
     }
     if (utf32_array[i] > 0xFFFF) {
       utf16_len += 1;
     }
   }
   if (is_one_byte_string) {
     return OneByteString::New(utf32_array, array_len, space);
   }
   return TwoByteString::New(utf16_len, utf32_array, array_len, space);
@@ skipping 60 matching lines @@
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint16_t* utf16_array,
                   intptr_t array_len) {
   ASSERT(dst_offset >= 0);
   ASSERT(array_len >= 0);
   ASSERT(array_len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
     NoGCScope no_gc;
     for (intptr_t i = 0; i < array_len; ++i) {
-      ASSERT(utf16_array[i] <= 0x7F);
+      ASSERT(utf16_array[i] <= 0xFF);
       *OneByteString::CharAddr(dst, i + dst_offset) = utf16_array[i];
     }
   } else {
     ASSERT(dst.IsTwoByteString());
     NoGCScope no_gc;
     if (array_len > 0) {
       memmove(TwoByteString::CharAddr(dst, dst_offset),
               utf16_array,
               array_len * 2);
     }
@@ skipping 134 matching lines @@
     return Symbols::Empty();
   }
   if (begin_index > str.Length()) {
     return String::null();
   }
   String& result = String::Handle();
   bool is_one_byte_string = true;
   intptr_t char_size = str.CharSize();
   if (char_size == kTwoByteChar) {
     for (intptr_t i = begin_index; i < begin_index + length; ++i) {
-      if (str.CharAt(i) > 0x7F) {
+      if (str.CharAt(i) > 0xFF) {
         is_one_byte_string = false;
         break;
       }
     }
   }
   if (is_one_byte_string) {
     result ^= OneByteString::New(length, space);
   } else {
     result ^= TwoByteString::New(length, space);
   }
   String::Copy(result, 0, str, begin_index, length);
   return result.raw();
 }
 
 
 const char* String::ToCString() const {
   intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<const char*>(result);
 }
 
 
 void String::ToUTF8(uint8_t* utf8_array, intptr_t array_len) const {
-  if (CharSize() == kOneByteChar) {
-    const String& obj = *this;
-    ASSERT(array_len >= obj.Length());
-    if (obj.Length() > 0) {
-      memmove(utf8_array, OneByteString::CharAddr(obj, 0), obj.Length());
-    }
-  } else {
-    ASSERT(array_len >= Utf8::Length(*this));
-    Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
-  }
+  ASSERT(array_len >= Utf8::Length(*this));
+  Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
 }
 
 
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   bool has_mapping = false;
   int32_t dst_max = 0;
   intptr_t len = str.Length();
   // TODO(cshapiro): assume a transform is required, rollback if not.
   for (intptr_t i = 0; i < len; ++i) {
     int32_t src = str.CharAt(i);
     int32_t dst = mapping(src);
     if (src != dst) {
       has_mapping = true;
     }
     dst_max = Utils::Maximum(dst_max, dst);
   }
   if (!has_mapping) {
     return str.raw();
   }
-  if (dst_max <= 0x7F) {
+  if (dst_max <= 0xFF) {
     return OneByteString::Transform(mapping, str, space);
   }
-  ASSERT(dst_max > 0x7F);
+  ASSERT(dst_max > 0xFF);
   return TwoByteString::Transform(mapping, str, space);
 }
 
 
 RawString* String::ToUpperCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
@@ skipping 127 matching lines @@
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result =String::Handle(OneByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
-    ASSERT(characters[i] <= 0x7F);
+    ASSERT(characters[i] <= 0xFF);
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const uint32_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
-    ASSERT(characters[i] <= 0x7F);
+    ASSERT(characters[i] <= 0xFF);
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const String& str,
                                      Heap::Space space) {
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
@@ skipping 33 matching lines @@
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
-    ASSERT(ch >= 0 && ch <= 0x7F);
+    ASSERT(ch >= 0 && ch <= 0xFF);
     *CharAddr(result, i) = ch;
   }
   return OneByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str,
                                                          bool raw_str) {
   intptr_t len = str.Length();
   if (len > 0) {
@@ skipping 1369 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart