Check that the C string passed to Dart_NewString is valid UTF-8.

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"
 
@@ skipping 58 matching lines @@
   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 char* str, intptr_t* width) {
   bool is_two_byte_string = false;
   bool is_four_byte_string = false;
   intptr_t len = 0;
   for (; *str != '\0'; ++str) {
     uint8_t code_unit = *str;
     if (!IsTrailByte(code_unit)) {
       ++len;
     }
     if (code_unit > 0xC3) {  // > U+00FF
       if (code_unit < 0xF0) {  // < U+10000
         is_two_byte_string = true;
       } else {
         is_four_byte_string = true;
       }
     }
   }
   if (is_four_byte_string) {
     *width = 4;
   } else if (is_two_byte_string) {
     *width = 2;
   } else {
     *width = 1;
   }
   return len;
 }
 
 
+// Returns true if str is a valid NUL-terminated UTF-8 string.
+bool Utf8::IsValid(const char* str) {
+  intptr_t i = 0;
+  while (str[i] != '\0') {
+    uint32_t ch = str[i] & 0xFF;
+    intptr_t j = 1;
+    if (ch >= 0x80) {
+      uint8_t num_trail_bytes = kTrailBytes[ch];
+      bool is_malformed = false;
+      for (; j < num_trail_bytes; ++j) {
+        if (str[i + j] != '\0') {
+          uint8_t code_unit = str[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) &&
+            !IsNonShortestForm(ch, j) &&
+            !IsSurrogate(ch))) {
+        return false;
+      }
+    }
+    i += j;
+  }
+  return true;
+}
+
+
 intptr_t Utf8::Length(int32_t ch) {
   if (ch <= kMaxOneByteChar) {
     return 1;
   } else if (ch <= kMaxTwoByteChar) {
     return 2;
   } else if (ch <= kMaxThreeByteChar) {
     return 3;
   }
   ASSERT(ch <= kMaxFourByteChar);
   return 4;
@@ skipping 110 matching lines @@
 bool Utf8::Decode(const char* src, uint16_t* dst, intptr_t len) {
   return DecodeImpl(src, dst, len);
 }
 
 
 bool Utf8::Decode(const char* src, uint32_t* dst, intptr_t len) {
   return DecodeImpl(src, dst, len);
 }
 
 }  // namespace dart