Implement case mapping using the Unicode default case mapping algorithm.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 5054 matching lines @@
 }
 
 
 int32_t String::CharAt(intptr_t index) const {
   // String is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
 
+void String::SetCharAt(intptr_t index, int32_t value) const {
+  // String is an abstract class.
+  UNREACHABLE();
+}
+
+
 bool String::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsString() || other.IsNull()) {
     return false;
   }
 
@@ skipping 629 matching lines @@
 const char* String::ToCString() const {
   intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   char* result = reinterpret_cast<char*>(zone->Allocate(len + 1));
   Utf8::Encode(*this, result, len);
   result[len] = 0;
   return result;
 }
 
 
+template<typename T>
+static RawString* CaseMappingImpl(T mapping,
+                                  const String& str,
+                                  Heap::Space space) {
+  ASSERT(!str.IsNull());

[Ivan Posva, 2011/10/18 22:01:13]

Please add a TODO in this function that outlines some of the optimizations we
could attempt to implement here.

[cshapiro, 2011/10/20 02:35:05]

Done.  I have added a TODO here about speculation.  In the ToUpperCase and
ToLowerCase methods I have added a TODO about creating a Latin-1 fast path.  If
I missed something, let me know.

+  bool has_mapping = false;
+  int32_t dst_max = -1;
+  intptr_t len = str.Length();
+  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 <= 0xFF) {
+    const OneByteString& onestr =
+        OneByteString::Handle(OneByteString::New(len, space));
+    for (intptr_t i = 0; i < len; ++i) {
+      onestr.SetCharAt(i, mapping(str.CharAt(i)));
+    }
+    return onestr.raw();
+  }
+  if (dst_max <= 0xFFFF) {
+    const TwoByteString& twostr =
+        TwoByteString::Handle(TwoByteString::New(len, space));
+    for (intptr_t i = 0; i < len; ++i) {
+      twostr.SetCharAt(i, mapping(str.CharAt(i)));
+    }
+    return twostr.raw();
+  }
+  ASSERT(dst_max > 0xFFFF);
+  const FourByteString& fourstr =
+      FourByteString::Handle(FourByteString::New(len, space));
+  for (intptr_t i = 0; i < len; ++i) {
+    fourstr.SetCharAt(i, mapping(str.CharAt(i)));
+  }
+  return fourstr.raw();
+}
+
+
+RawString* String::ToUpperCase(const String& str, Heap::Space space) {
+  return CaseMappingImpl(CaseMapping::ToUpper, str, space);
+}
+
+
+RawString* String::ToLowerCase(const String& str, Heap::Space space) {
+  return CaseMappingImpl(CaseMapping::ToLower, str, space);
+}
+
+
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->one_byte_string_class());
   OneByteString& result = OneByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       OneByteString::InstanceSize(len),
@@ skipping 711 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart