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 5703 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;
 }
 
 
+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 <= 0xFF) {
+    return OneByteString::Transform(mapping, str, space);
+  }
+  if (dst_max <= 0xFFFF) {
+    return TwoByteString::Transform(mapping, str, space);
+  }
+  ASSERT(dst_max > 0xFFFF);
+  return FourByteString::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);
+}
+
+
 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 82 matching lines @@
   OneByteString& result = OneByteString::Handle();
   if (length <= (str.Length() - begin_index)) {
     result ^= OneByteString::New(length, space);
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
 
 
+RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
+                                           const String& str,
+                                           Heap::Space space) {
+  ASSERT(!str.IsNull());
+  intptr_t len = str.Length();
+  const OneByteString& onestr =

[Ivan Posva, 2011/10/21 14:03:37]

onestr -> result?

[cshapiro, 2011/10/21 20:29:08]

Yes, that would be more consistent.  Renamed.

+      OneByteString::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);
+    *onestr.CharAddr(i) = ch;
+  }
+  return onestr.raw();
+}
+
+
 const char* OneByteString::ToCString() const {
   return String::ToCString();
 }
 
 
 RawTwoByteString* TwoByteString::New(intptr_t len,
                                      Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
@@ skipping 79 matching lines @@
   TwoByteString& result = TwoByteString::Handle();
   if (length <= (str.Length() - begin_index)) {
     result ^= TwoByteString::New(length, space);
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
 
 
+RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
+                                           const String& str,
+                                           Heap::Space space) {
+  ASSERT(!str.IsNull());
+  intptr_t len = str.Length();
+  const TwoByteString& twostr =

[Ivan Posva, 2011/10/21 14:03:37]

ditto

[cshapiro, 2011/10/21 20:29:08]

Done.

+      TwoByteString::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);
+    *twostr.CharAddr(i) = ch;
+  }
+  return twostr.raw();
+}
+
+
 const char* TwoByteString::ToCString() const {
   return String::ToCString();
 }
 
 
-
 RawFourByteString* FourByteString::New(intptr_t len,
                                        Heap::Space space) {
   Isolate* isolate = Isolate::Current();
 
   const Class& cls =
       Class::Handle(isolate->object_store()->four_byte_string_class());
   FourByteString& result = FourByteString::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       FourByteString::InstanceSize(len),
@@ skipping 66 matching lines @@
   FourByteString& result = FourByteString::Handle();
   if (length <= (str.Length() - begin_index)) {
     result ^= FourByteString::New(length, space);
     String::Copy(result, 0, str, begin_index, length);
   }
   // TODO(5418937): return a non-null object on error.
   return result.raw();
 }
 
 
+RawFourByteString* FourByteString::Transform(int32_t (*mapping)(int32_t ch),
+                                             const String& str,
+                                             Heap::Space space) {
+  ASSERT(!str.IsNull());
+  intptr_t len = str.Length();
+  const FourByteString& fourstr =

[Ivan Posva, 2011/10/21 14:03:37]

ditto

[cshapiro, 2011/10/21 20:29:08]

Done.

+      FourByteString::Handle(FourByteString::New(len, space));
+  for (intptr_t i = 0; i < len; ++i) {
+    int32_t ch = mapping(str.CharAt(i));
+    ASSERT(ch >= 0 && ch <= 0x10FFFF);
+    *fourstr.CharAddr(i) = ch;
+  }
+  return fourstr.raw();
+}
+
+
 const char* FourByteString::ToCString() const {
   return String::ToCString();
 }
 
 
 RawBool* Bool::True() {
   return Isolate::Current()->object_store()->true_value();
 }
 
 
@@ skipping 418 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