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

runtime/vm/unicode.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/unicode.h"
 
 #include "vm/allocation.h"
 #include "vm/globals.h"
 #include "vm/object.h"
 
 namespace dart {
 
-static const int8_t kTrailBytes[256] = {
+const int8_t Utf8::kTrailBytes[256] = {
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0, 0
 };
 
 
-static const uint32_t kMagicBits[7] = {
+const uint32_t Utf8::kMagicBits[7] = {
   0,  // padding
   0x00000000,
   0x00003080,
   0x000E2080,
   0x03C82080,
   0xFA082080,
   0x82082080
 };
 
 
 // Minimum values of code points used to check shortest form.
-static const uint32_t kOverlongMinimum[7] = {
+const uint32_t Utf8::kOverlongMinimum[7] = {
   0,  // padding
   0x0,
   0x80,
   0x800,
   0x10000,
   0xFFFFFFFF,
   0xFFFFFFFF
 };
 
 
-static bool IsTrailByte(uint8_t code_unit) {
-  return (code_unit & 0xc0) == 0x80;
-}
-
-
-static bool IsLatin1SequenceStart(uint8_t code_unit) {
-  // Check is codepoint is <= U+00FF
-  return (code_unit <= Utf8::kMaxOneByteChar);
-}
-
-
-static bool IsSupplementarySequenceStart(uint8_t code_unit) {
-  // Check is codepoint is >= U+10000.
-  return (code_unit >= 0xF0);
-}
-
-
-// Returns true if the code point value is above Plane 17.
-static bool IsOutOfRange(uint32_t code_point) {
-  return (code_point > 0x10FFFF);
-}
-
-
-// Returns true if the byte sequence is ill-formed.
-static bool IsNonShortestForm(uint32_t code_point, size_t num_bytes) {
-  return code_point < kOverlongMinimum[num_bytes];
-}
-
-
 // Returns a count of the number of UTF-8 trail bytes.
 intptr_t Utf8::CodePointCount(const uint8_t* utf8_array,
                               intptr_t array_len,
                               Type* type) {
   intptr_t len = 0;
   Type char_type = kLatin1;
   for (intptr_t i = 0; i < array_len; i++) {
     uint8_t code_unit = utf8_array[i];
     if (!IsTrailByte(code_unit)) {
       ++len;
@@ skipping 26 matching lines @@
           uint8_t code_unit = utf8_array[i + j];
           is_malformed |= !IsTrailByte(code_unit);
           ch = (ch << 6) + code_unit;
         } else {
           return false;
         }
       }
       ch -= kMagicBits[num_trail_bytes];
       if (!((is_malformed == false) &&
             (j == num_trail_bytes) &&
-            !IsOutOfRange(ch) &&
+            !Utf::IsOutOfRange(ch) &&
             !IsNonShortestForm(ch, j) &&
             !Utf16::IsSurrogate(ch))) {
         return false;
       }
     }
     i += j;
   }
   return true;
 }
 
@@ skipping 78 matching lines @@
         is_malformed |= !IsTrailByte(code_unit);
         ch = (ch << 6) + code_unit;
       } else {
         *dst = -1;
         return 0;
       }
     }
     ch -= kMagicBits[num_trail_bytes];
     if (!((is_malformed == false) &&
           (i == num_trail_bytes) &&
-          !IsOutOfRange(ch) &&
+          !Utf::IsOutOfRange(ch) &&
           !IsNonShortestForm(ch, i) &&
           !Utf16::IsSurrogate(ch))) {
       *dst = -1;
       return 0;
     }
   }
   *dst = ch;
   return i;
 }
 
 
 bool Utf8::DecodeToLatin1(const uint8_t* utf8_array,
                           intptr_t array_len,
                           uint8_t* dst,
                           intptr_t len) {
   intptr_t i = 0;
   intptr_t j = 0;
   intptr_t num_bytes;
   for (; (i < array_len) && (j < len); i += num_bytes, ++j) {
     int32_t ch;
     ASSERT(IsLatin1SequenceStart(utf8_array[i]));
     num_bytes = Utf8::Decode(&utf8_array[i], (array_len - i), &ch);
     if (ch == -1) {
       return false;  // invalid input
     }
-    ASSERT(ch <= 0xff);
+    ASSERT(Utf::IsLatin1(ch));
     dst[j] = ch;
   }
   if ((i < array_len) && (j == len)) {
     return false;  // output overflow
   }
   return true;  // success
 }
 
 
 bool Utf8::DecodeToUTF16(const uint8_t* utf8_array,
@@ skipping 39 matching lines @@
     }
     dst[j] = ch;
   }
   if ((i < array_len) && (j == len)) {
     return false;  // output overflow
   }
   return true;  // success
 }
 
 
+bool Utf8::DecodeCStringToUTF32(const char* str, int32_t* dst, intptr_t len) {
+  ASSERT(str != NULL);
+  intptr_t array_len = strlen(str);
+  const uint8_t* utf8_array = reinterpret_cast<const uint8_t*>(str);
+  return Utf8::DecodeToUTF32(utf8_array, array_len, dst, len);
+}
+
+
 void Utf16::Encode(int32_t codepoint, uint16_t* dst) {
-  ASSERT(codepoint > kMaxBmpCodepoint);
+  ASSERT(codepoint > Utf16::kMaxCodeUnit);
   ASSERT(dst != NULL);
   dst[0] = (Utf16::kLeadSurrogateOffset + (codepoint >> 10));
   dst[1] = (0xDC00 + (codepoint & 0x3FF));
 }
 
 }  // namespace dart