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 3679 matching lines @@
   static const intptr_t kMaxElements = kSmiMax / kTwoByteChar;
 
   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);
+  static intptr_t Hash(const int32_t* characters, intptr_t len);
 
+  // Despite the name, this does not return the character.  It 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

[siva, 2012/11/16 22:32:04]

Should we say ASCII or Latin1 here?

[erikcorry, 2012/11/19 12:40:41]

Now says both.

+  // arbitrary Unicode characters then you should perhaps be using
+  // Utf16::CharCodeAt(string, index), which returns the full 21 bit code point.
   int32_t CharAt(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;
-  bool Equals(const uint32_t* characters, intptr_t len) const;
+  bool Equals(const int32_t* characters, intptr_t len) const;
 
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
 
   virtual RawInstance* Canonicalize() const;
 
   bool IsSymbol() const { return raw()->IsCanonical(); }
@@ skipping 30 matching lines @@
   static RawString* New(const uint8_t* utf8_array,
                         intptr_t array_len,
                         Heap::Space space = Heap::kNew);
 
   // Creates a new String object from an array of UTF-16 encoded characters.
   static RawString* New(const uint16_t* utf16_array,
                         intptr_t array_len,
                         Heap::Space space = Heap::kNew);
 
   // Creates a new String object from an array of UTF-32 encoded characters.
-  static RawString* New(const uint32_t* utf32_array,
+  static RawString* New(const int32_t* utf32_array,
                         intptr_t array_len,
                         Heap::Space space = Heap::kNew);
 
   // Create a new String object from another Dart String instance.
   static RawString* New(const String& str, Heap::Space space = Heap::kNew);
 
   // Creates a new External String object using the specified array of
   // UTF-8 encoded characters as the external reference.
   static RawString* NewExternal(const uint8_t* utf8_array,
                                 intptr_t array_len,
@@ skipping 125 matching lines @@
     return New(reinterpret_cast<const uint8_t*>(c_string),
                strlen(c_string),
                space);
   }
   static RawOneByteString* New(const uint8_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
-  static RawOneByteString* New(const uint32_t* characters,
+  static RawOneByteString* New(const int32_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const String& str,
                                Heap::Space space);
 
   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,

[siva, 2012/11/16 22:32:04]

we always use intptr_t for length values in the VM

[erikcorry, 2012/11/19 12:40:41]

Done.

                                      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 48 matching lines @@
     return String::RoundedAllocationSize(
         sizeof(RawTwoByteString) + (len * kBytesPerElement));
   }
 
   static RawTwoByteString* New(intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(intptr_t utf16_len,
-                               const uint32_t* characters,
+                               const int32_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(const String& str,
                                Heap::Space space);
 
   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,

[siva, 2012/11/16 22:32:04]

Ditto.

[erikcorry, 2012/11/19 12:40:41]

Done.

                                      Heap::Space space);
 
   static RawTwoByteString* null() {
     return reinterpret_cast<RawTwoByteString*>(Object::null());
   }
 
 
   static const ClassId kClassId = kTwoByteStringCid;
 
  private:
@@ skipping 1870 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_