Add some support for the code-point code-unit distinction.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/scanner.h"
+#include "vm/unicode.h"
 
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
@@ skipping 3681 matching lines @@
   intptr_t Length() const { return Smi::Value(raw_ptr()->length_); }
   static intptr_t length_offset() { return OFFSET_OF(RawString, length_); }
 
   virtual intptr_t Hash() const;
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const uint32_t* characters, intptr_t len);
 
-  int32_t CharAt(intptr_t index) const;
+  // Returns the UTF-16 code unit at an index.  UTF-16 is a superset of ASCII
+  // so you can always use this if you are looking for ASCII.  If you need to
+  // support arbitrary Unicode characters then you should perhaps be using
+  // Utf16::CharCodeAt(string, index) instead.
+  uint32_t CodeUnitAt(intptr_t index) const;
 
   intptr_t CharSize() const;
 
   inline bool Equals(const String& str) const;
   inline bool Equals(const String& str,
                      intptr_t begin_index,  // begin index on 'str'.
                      intptr_t len) const;  // len on 'str'.
   bool Equals(const char* str) const;
   bool Equals(const uint8_t* characters, intptr_t len) const;
   bool Equals(const uint16_t* characters, intptr_t len) const;
@@ skipping 145 matching lines @@
   friend class Symbols;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
 };
 
 
 class OneByteString : public AllStatic {
  public:
-  static int32_t CharAt(const String& str, intptr_t index) {
+  static uint32_t CodeUnitAt(const String& str, intptr_t index) {

[cshapiro, 2012/11/15 20:14:51]

Why did the signedness of the return type change?  The values are maximally in
the 21-bit range.  Given how we use signed types pervasively in the VM this is
going to introduce opportunities for signedness mismatch warnings in the
compiler.

[erikcorry, 2012/11/15 23:47:05]

There is a mixture in the VM of signed and unsigned values for the strings.  For
example the data_ and external_data_ fields on raw strings are unsigned.  I was
getting signedness mismatch warnings from the compiler so I decided to
standardize on unsigned values.  In response to this comment here I have tried
standardizing on signed values, but that causes cascades of  changes throughout
the VM.  In the next patch set I have therefore used a mixture, but with a
tendency towards using int32_t where the values are 32 bit and unsigned types
for the 16 bit and 8 bit values.  This function (now named CharAt) is thus
signed again.

     return *CharAddr(str, index);
   }
 
   static RawOneByteString* EscapeSpecialCharacters(const String& str,
                                                    bool raw_str);
 
   static bool EqualsIgnoringPrivateKey(const String& str1,
                                        const String& str2);
 
   // We use the same maximum elements for all strings.
@@ skipping 36 matching lines @@
 
   static RawOneByteString* Concat(const String& str1,
                                   const String& str2,
                                   Heap::Space space);
   static RawOneByteString* ConcatAll(const Array& strings,
                                      intptr_t len,
                                      Heap::Space space);
 
   static RawOneByteString* Transform(int32_t (*mapping)(int32_t ch),
                                      const String& str,
+                                     int out_length,
                                      Heap::Space space);
 
   static const ClassId kClassId = kOneByteStringCid;
 
   static RawOneByteString* null() {
     return reinterpret_cast<RawOneByteString*>(Object::null());
   }
 
  private:
   static RawOneByteString* raw(const String& str) {
@@ skipping 17 matching lines @@
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class TwoByteString : public AllStatic {
  public:
-  static int32_t CharAt(const String& str, intptr_t index) {
+  static uint32_t CodeUnitAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
   }
 
   static RawTwoByteString* EscapeSpecialCharacters(const String& str,
                                                    bool raw_str);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
@@ skipping 25 matching lines @@
 
   static RawTwoByteString* Concat(const String& str1,
                                   const String& str2,
                                   Heap::Space space);
   static RawTwoByteString* ConcatAll(const Array& strings,
                                      intptr_t len,
                                      Heap::Space space);
 
   static RawTwoByteString* Transform(int32_t (*mapping)(int32_t ch),
                                      const String& str,
+                                     int out_length,
                                      Heap::Space space);
 
   static RawTwoByteString* null() {
     return reinterpret_cast<RawTwoByteString*>(Object::null());
   }
 
 
   static const ClassId kClassId = kTwoByteStringCid;
 
  private:
@@ skipping 18 matching lines @@
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalOneByteString : public AllStatic {
  public:
-  static int32_t CharAt(const String& str, intptr_t index) {
+  static uint32_t CodeUnitAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
@@ skipping 45 matching lines @@
                                             Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalTwoByteString : public AllStatic {
  public:
-  static int32_t CharAt(const String& str, intptr_t index) {
+  static uint32_t CodeUnitAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
@@ skipping 1755 matching lines @@
                     intptr_t begin_index,
                     intptr_t len) const {
   ASSERT(begin_index >= 0);
   ASSERT((begin_index == 0) || (begin_index < str.Length()));
   ASSERT(len >= 0);
   ASSERT(len <= str.Length());
   if (len != this->Length()) {
     return false;  // Lengths don't match.
   }
   for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != str.CharAt(begin_index + i)) {
+    if (this->CodeUnitAt(i) != str.CodeUnitAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_