Move various top-level Unicode definitions into classes and methods.

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 10069 matching lines @@
                       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] > 0xFF) {
+    if (!Utf::IsLatin1(utf16_array[i])) {
       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 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) {
+    if (!Utf::IsLatin1(utf32_array[i])) {
       is_one_byte_string = false;
-    }
-    if (utf32_array[i] > 0xFFFF) {
-      utf16_len += 1;
+      if (Utf::IsSupplementary(utf32_array[i])) {
+        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);
 }
 
 
 RawString* String::New(const String& str, Heap::Space space) {
@@ skipping 56 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] <= 0xFF);
+      ASSERT(Utf::IsLatin1(utf16_array[i]));
       *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) > 0xFF) {
+      if (!Utf::IsLatin1(str.CharAt(i))) {
         is_one_byte_string = false;
         break;
       }
     }
   }
   if (is_one_byte_string) {
     result ^= OneByteString::New(length, space);
   } else {
     result ^= TwoByteString::New(length, space);
   }
@@ skipping 115 matching lines @@
     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) {
+  if (Utf::IsLatin1(dst_max)) {
     return OneByteString::Transform(mapping, str, space);
   }
-  ASSERT(dst_max > 0xFF);
+  ASSERT(Utf::IsBmp(dst_max) || Utf::IsSupplementary(dst_max));
   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 146 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] <= 0xFF);
+    ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 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);
+    ASSERT(Utf::IsLatin1(characters[i]));
     *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 49 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 <= 0xFF);
+    ASSERT(Utf::IsLatin1(ch));
     *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 64 matching lines @@
 RawTwoByteString* TwoByteString::New(intptr_t utf16_len,
                                      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) {
+      if (Utf::IsSupplementary(utf32_array[i])) {
         ASSERT(j < (utf16_len - 1));
         Utf16::Encode(utf32_array[i], CharAddr(result, j));
         j += 2;
       } else {
         ASSERT(j < utf16_len);
         *CharAddr(result, j) = utf32_array[i];
         j += 1;
       }
     }
   }
@@ skipping 1255 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart