Add some support for the code-point code-unit distinction.

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 2217 matching lines @@
                                 const char* prefix,
                                 intptr_t prefix_length,
                                 const String& accessor_name) {
   intptr_t name_len = name.Length();
   intptr_t accessor_name_len = accessor_name.Length();
 
   if (name_len != (accessor_name_len + prefix_length)) {
     return false;
   }
   for (intptr_t i = 0; i < prefix_length; i++) {
-    if (name.CharAt(i) != prefix[i]) {
+    if (name.CharAt(i) != static_cast<int32_t>(prefix[i])) {
       return false;
     }
   }
   for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
@@ skipping 6907 matching lines @@
 
 
 const char* Integer::ToCString() const {
   // Integer is an interface. No instances of Integer should exist.
   UNREACHABLE();
   return "Integer";
 }
 
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
-  // We are not supposed to have integers represented as two byte or
-  // four byte strings.
+  // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big = Bigint::Handle(Bigint::New(str, space));
     ASSERT(!BigintOperations::FitsIntoSmi(big));
     ASSERT(!BigintOperations::FitsIntoMint(big));
     return big.raw();
   }
   return Integer::New(value, space);
 }
@@ skipping 742 matching lines @@
 intptr_t String::Hash(const uint8_t* characters, intptr_t len) {
   return HashImpl(characters, len);
 }
 
 
 intptr_t String::Hash(const uint16_t* characters, intptr_t len) {
   return HashImpl(characters, len);
 }
 
 
-intptr_t String::Hash(const uint32_t* characters, intptr_t len) {
+intptr_t String::Hash(const int32_t* characters, intptr_t len) {
   return HashImpl(characters, len);
 }
 
 
 int32_t String::CharAt(intptr_t index) const {
   intptr_t class_id = raw()->GetClassId();
   ASSERT(RawObject::IsStringClassId(class_id));
   NoGCScope no_gc;
   if (class_id == kOneByteStringCid) {
       return *OneByteString::CharAddr(*this, index);
@@ skipping 54 matching lines @@
   intptr_t len = strlen(str);
   for (intptr_t i = 0; i < this->Length(); ++i) {
     if (*str == '\0') {
       // Lengths don't match.
       return false;
     }
     int32_t ch;
     intptr_t consumed = Utf8::Decode(reinterpret_cast<const uint8_t*>(str),
                                      len,
                                      &ch);
-    if (consumed == 0 || this->CharAt(i) != ch) {
-      return false;
+    if (consumed == 0) return false;
+
+    if (ch <= Utf16::kMaxCodeUnit) {
+      if (this->CharAt(i) != ch) return false;
+    } else {
+      if (Utf16::CodePointAt(*this, i) != ch) return false;
+      i++;
     }
     str += consumed;
     len -= consumed;
   }
   return *str == '\0';
 }
 
 
 bool String::Equals(const uint8_t* characters, intptr_t len) const {
   if (len != this->Length()) {
@@ skipping 18 matching lines @@
 
   for (intptr_t i = 0; i < len; i++) {
     if (this->CharAt(i) != characters[i]) {
       return false;
     }
   }
   return true;
 }
 
 
-bool String::Equals(const uint32_t* characters, intptr_t len) const {
-  if (len != this->Length()) {
-    // Lengths don't match.
-    return false;
-  }
-
-  for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != static_cast<int32_t>(characters[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 intptr_t String::CompareTo(const String& other) const {
   const intptr_t this_len = this->Length();
   const intptr_t other_len = other.IsNull() ? 0 : other.Length();
   const intptr_t len = (this_len < other_len) ? this_len : other_len;
+  // UTF-16 has the high surrogate before the low surrogate so we can compare
+  // one code unit at a time for efficiency and still get the right ordering.
   for (intptr_t i = 0; i < len; i++) {
-    int32_t this_code_point = this->CharAt(i);
-    int32_t other_code_point = other.CharAt(i);
-    if (this_code_point < other_code_point) {
+    int32_t this_code_unit = this->CharAt(i);
+    int32_t other_code_unit = other.CharAt(i);
+    if (this_code_unit < other_code_unit) {
       return -1;
     }
-    if (this_code_point > other_code_point) {
+    if (this_code_unit > other_code_unit) {
       return 1;
     }
   }
   if (this_len < other_len) return -1;
   if (this_len > other_len) return 1;
   return 0;
 }
 
 
 bool String::StartsWith(const String& other) const {
@@ skipping 23 matching lines @@
   intptr_t array_len = strlen(str);
   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);
+  intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
   if (type == Utf8::kLatin1) {
     const String& strobj = String::Handle(OneByteString::New(len, space));
     if (len > 0) {
       NoGCScope no_gc;
       Utf8::DecodeToLatin1(utf8_array, array_len,
                            OneByteString::CharAddr(strobj, 0), len);
     }
     return strobj.raw();
   }
   ASSERT((type == Utf8::kBMP) || (type == Utf8::kSMP));
@@ skipping 15 matching lines @@
       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,
+RawString* String::New(const int32_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] > 0xFF) {
       is_one_byte_string = false;
     }
     if (utf32_array[i] > 0xFFFF) {
       utf16_len += 1;
@@ skipping 345 matching lines @@
 }
 
 
 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();
+  intptr_t out_len = 0;
   // TODO(cshapiro): assume a transform is required, rollback if not.
-  for (intptr_t i = 0; i < len; ++i) {
+  intptr_t i = 0;
+  for (; i < len; ++i) {
     int32_t src = str.CharAt(i);
+    if (Utf16::IsSurrogate(src)) break;
     int32_t dst = mapping(src);
     if (src != dst) {
       has_mapping = true;
     }
     dst_max = Utils::Maximum(dst_max, dst);
+    out_len += dst > Utf16::kMaxCodeUnit ? 2 : 1;
+  }
+  for (; i < len; ++i) {
+    int32_t src = Utf16::CodePointAt(str, i);
+    int32_t dst = mapping(src);
+    if (src != dst) {
+      has_mapping = true;
+    }
+    dst_max = Utils::Maximum(dst_max, dst);
+    out_len += dst > Utf16::kMaxCodeUnit ? 2 : 1;
+    if (src > Utf16::kMaxCodeUnit) ++i;
   }
   if (!has_mapping) {
     return str.raw();
   }
   if (dst_max <= 0xFF) {
-    return OneByteString::Transform(mapping, str, space);
+    return OneByteString::Transform(mapping, str, out_len, space);
   }
   ASSERT(dst_max > 0xFF);
-  return TwoByteString::Transform(mapping, str, space);
+  return TwoByteString::Transform(mapping, str, out_len, 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);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
@@ skipping 133 matching lines @@
                                      Heap::Space space) {
   const String& result =String::Handle(OneByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(characters[i] <= 0xFF);
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
-RawOneByteString* OneByteString::New(const uint32_t* characters,
+RawOneByteString* OneByteString::New(const int32_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] <= 0xFF);
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
@@ skipping 32 matching lines @@
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
+                                           intptr_t out_length,
                                            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 <= 0xFF);
-    *CharAddr(result, i) = ch;
+  const String& result =
+      String::Handle(OneByteString::New(out_length, space));
+  for (intptr_t i = 0, j = 0; i < len; ++i, j++) {
+    int32_t old_ch = str.CharAt(i);
+    if (old_ch > Utf16::kMaxCodeUnit) i++;
+    int32_t ch = mapping(old_ch);
+    ASSERT(ch <= 0xFF);
+    *CharAddr(result, j) = ch;
   }
   return OneByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str,
                                                          bool raw_str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
@@ skipping 54 matching lines @@
   const String& result = String::Handle(TwoByteString::New(array_len, space));
   {
     NoGCScope no_gc;
     memmove(CharAddr(result, 0), utf16_array, (array_len * 2));
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::New(intptr_t utf16_len,
-                                     const uint32_t* utf32_array,
+                                     const int32_t* utf32_array,
                                      intptr_t array_len,
                                      Heap::Space space) {
   ASSERT((array_len > 0) && (utf16_len >= array_len));
   const String& result = String::Handle(TwoByteString::New(utf16_len, space));
   {
     NoGCScope no_gc;
     intptr_t j = 0;
     for (intptr_t i = 0; i < array_len; ++i) {
-      if (utf32_array[i] > 0xffff) {
+      int32_t code_point = utf32_array[i];
+      if (code_point > Utf16::kMaxCodeUnit) {
         ASSERT(j < (utf16_len - 1));
-        Utf8::ConvertUTF32ToUTF16(utf32_array[i], CharAddr(result, j));
+        *CharAddr(result, j) = Utf16::LeadFromCodePoint(code_point);
+        *CharAddr(result, j + 1) = Utf16::TrailFromCodePoint(code_point);
         j += 2;
       } else {
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
       }
     }
   }
   return TwoByteString::raw(result);
 }
@@ skipping 33 matching lines @@
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
+                                           intptr_t out_length,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
-  const String& result = String::Handle(TwoByteString::New(len, space));
-  for (intptr_t i = 0; i < len; ++i) {
-    int32_t ch = mapping(str.CharAt(i));
-    ASSERT(ch >= 0 && ch <= 0xFFFF);
-    *CharAddr(result, i) = ch;
+  const String& result =
+      String::Handle(TwoByteString::New(out_length, space));
+  for (intptr_t i = 0, j = 0; i < len; ++i, j++) {
+    int32_t old_ch = Utf16::CodePointAt(str, i);
+    if (old_ch > Utf16::kMaxCodeUnit) i++;
+    int32_t ch = mapping(old_ch);
+    ASSERT(ch <= Utf16::kMaxCodePoint);
+    if (ch <= Utf16::kMaxCodeUnit) {
+      *CharAddr(result, j) = ch;
+    } else {
+      *CharAddr(result, j) = Utf16::LeadFromCodePoint(ch);
+      *CharAddr(result, j + 1) = Utf16::TrailFromCodePoint(ch);
+      ++j;
+    }
+    ASSERT(j <= out_length);
   }
   return TwoByteString::raw(result);
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::New(
     const uint8_t* data,
     intptr_t len,
     void* peer,
     Dart_PeerFinalizer callback,
@@ skipping 1182 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart