Provide a code point iterator to the String class to simplify iteration.

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 9972 matching lines @@
 
   const String& other_string = String::Cast(other);
   if (this->HasHash() && other_string.HasHash() &&
       (this->Hash() != other_string.Hash())) {
     return false;  // Both sides have a hash code and it does not match.
   }
   return Equals(other_string, 0, other_string.Length());
 }
 
 
-bool String::Equals(const char* str) const {
-  ASSERT(str != NULL);
-  intptr_t len = strlen(str);
+bool String::Equals(const char* utf8_array) const {
+  ASSERT(utf8_array != NULL);
+  intptr_t len = strlen(utf8_array);
   for (intptr_t i = 0; i < this->Length(); ++i) {
-    if (*str == '\0') {
+    if (*utf8_array == '\0') {
       // Lengths don't match.
       return false;
     }
     int32_t ch;
-    intptr_t consumed = Utf8::Decode(reinterpret_cast<const uint8_t*>(str),
-                                     len,
-                                     &ch);
+    intptr_t consumed = Utf8::Decode(
+        reinterpret_cast<const uint8_t*>(utf8_array),
+        len,
+        &ch);
     if (consumed == 0 || this->CharAt(i) != ch) {
       return false;
     }
-    str += consumed;
+    utf8_array += consumed;
     len -= consumed;
   }
-  return *str == '\0';
+  return *utf8_array == '\0';
 }
 
 
-bool String::Equals(const uint8_t* characters, intptr_t len) const {
+bool String::Equals(const uint8_t* latin1_array, 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) != characters[i]) {
+    if (this->CharAt(i) != latin1_array[i]) {
       return false;
     }
   }
   return true;
 }
 
 
-bool String::Equals(const uint16_t* characters, intptr_t len) const {
+bool String::Equals(const uint16_t* utf16_array, 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) != characters[i]) {
+    if (this->CharAt(i) != utf16_array[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])) {
+bool String::Equals(const uint32_t* utf32_array, intptr_t len) const {
+  CodePointIterator it(*this);
+  intptr_t i = 0;
+  while (it.Next()) {
+    if (it.Current() != static_cast<int32_t>(utf32_array[i])) {
       return false;
     }
+    ++i;
+  }
+  if (i != len) {
+    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;
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 440 matching lines @@
   return this->raw();
 }
 
 
 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);
+  CodePointIterator it(str);
+  while (it.Next()) {
+    int32_t src = it.Current();
     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 <= 0xFF) {
     return OneByteString::Transform(mapping, str, space);
   }
   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);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 
+int32_t String::CodePointIterator::Current() {
+  ASSERT(index_ >= 0);
+  ASSERT(index_ < str_.Length());
+  int32_t ch = str_.CharAt(index_);
+  if (Utf16::IsLeadSurrogate(ch) && (index_ != (str_.Length() - 1))) {

[siva, 2012/11/19 18:25:29]

Shouldn't this be (index_ < (str_.Length() - 1))

[cshapiro, 2012/11/19 18:55:11]

Removed in the re-upload.

+    ASSERT(str_.IsTwoByteString());
+    int32_t ch2 = str_.CharAt(index_ + 1);
+    if (Utf16::IsTrailSurrogate(ch2)) {
+      ch = Utf16::Decode(ch, ch2);
+    }
+  }
+  return ch;
+}
+
+
+bool String::CodePointIterator::Next() {
+  ASSERT(index_ >= -1);
+  ASSERT(index_ < str_.Length());
+  if (index_ == (str_.Length() - 1)) {

[siva, 2012/11/19 18:25:29]

Why not just make this
if (index_ >= (str_.Length() - 1)) {
  return false;
}
and remove ASSERT(index_ < str.Length());

[cshapiro, 2012/11/19 18:55:11]

I am not sure what this simplifies.  Having the index value range from [-1,
(Length-1)] makes it easier to check the invariants.

+    return false;
+  }
+  ++index_;
+  int32_t ch2 = str_.CharAt(index_);
+  if (Utf16::IsTrailSurrogate(ch2)) {
+    ASSERT(str_.IsTwoByteString());
+    if (index_ != 0) {
+      int32_t ch = str_.CharAt(index_ - 1);
+      if (Utf16::IsLeadSurrogate(ch)) {
+        if (index_ == (str_.Length() - 1)) {
+          --index_;
+          return false;
+        }
+        ++index_;
+      }

[siva, 2012/11/19 18:25:29]

If you structure the code as discussed offline it would
be more readable.

+    }
+  }
+  return true;
+}
+
+
 RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str,
                                                          bool raw_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) == '\\'))) {
         num_escapes += 1;
@@ skipping 264 matching lines @@
                                      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) {
         ASSERT(j < (utf16_len - 1));
-        Utf8::ConvertUTF32ToUTF16(utf32_array[i], CharAddr(result, j));
+        Utf16::Encode(utf32_array[i], CharAddr(result, j));
         j += 2;
       } else {
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
       }
     }
   }
   return TwoByteString::raw(result);
 }
@@ skipping 37 matching lines @@
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::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(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;
+  String::CodePointIterator it(str);
+  intptr_t i = 0;
+  while (it.Next()) {
+    int32_t src = it.Current();
+    int32_t dst = mapping(src);
+    ASSERT(dst >= 0 && dst <= 0x10FFFF);
+    if (dst <= 0xFFFF) {
+      *CharAddr(result, i) = dst;
+      i += 1;
+    } else {
+      Utf16::Encode(dst, CharAddr(result, i));
+      i += 2;
+    }
   }
   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