Merged String subclasses into String.

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"
@@ skipping 3625 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);
 
-  virtual int32_t CharAt(intptr_t index) const;
+  int32_t CharAt(intptr_t index) const;
 
-  virtual intptr_t CharSize() 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;
 
   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(); }
 
-  virtual bool IsExternal() const { return false; }
-  virtual void* GetPeer() const {
-    UNREACHABLE();
-    return NULL;
+  bool IsOneByteString() const {
+    return raw()->GetClassId() == kOneByteStringCid;
   }
 
+  bool IsTwoByteString() const {
+    return raw()->GetClassId() == kTwoByteStringCid;
+  }
+
+  bool IsExternalOneByteString() const {
+    return raw()->GetClassId() == kExternalOneByteStringCid;
+  }
+
+  bool IsExternalTwoByteString() const {
+    return raw()->GetClassId() == kExternalTwoByteStringCid;
+  }
+
+  bool IsExternal() const;

[siva, 2012/11/02 01:15:25]

why not inline this too:
{
  return IsExternalOneByteString() || IsExternalTwoByteString();
}

[Tom Ball, 2012/11/02 23:31:50]

Good idea -- I also found that RawObject::IsExternalStringClassId() has the same
assertion, so used that inlined function.

+
+  void* GetPeer() const;
+
   void ToUTF8(uint8_t* utf8_array, intptr_t array_len) const;
 
   // Creates a new String object from a C string that is assumed to contain
   // UTF-8 encoded characters and '\0' is considered a termination character.
   static RawString* New(const char* cstr, Heap::Space space = Heap::kNew);
 
   // Creates a new String object from an array of UTF-8 encoded characters.
   static RawString* New(const uint8_t* utf8_array,
                         intptr_t array_len,
                         Heap::Space space = Heap::kNew);
@@ skipping 83 matching lines @@
   }
 
   void SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->hash_ = Smi::New(value);
   }
 
   template<typename HandleType, typename ElementType>
   static void ReadFromImpl(SnapshotReader* reader,
-                           HandleType* str_obj,
+                           String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            Snapshot::Kind kind);
 
   HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 
   friend class Symbols;
+  friend class OneByteString;
+  friend class TwoByteString;
+  friend class ExternalOneByteString;
+  friend class ExternalTwoByteString;
 };
 
 
 class OneByteString : public String {

[siva, 2012/11/02 01:15:25]

We does this have to inherit from String

Shouldn't it be:
class OneByteString : public AllStatic {

[Tom Ball, 2012/11/02 23:31:50]

Done.

  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kOneByteChar;
-  }
+  static RawOneByteString* EscapeSpecialCharacters(const String& str,
+                                                   bool raw_str);
 
-  RawOneByteString* EscapeSpecialCharacters(bool raw_str) const;
-
-  bool EqualsIgnoringPrivateKey(const OneByteString& str) const;
+  static bool EqualsIgnoringPrivateKey(const String& str1,
+                                       const String& str2);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() { return OFFSET_OF(RawOneByteString, data_); }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) == OFFSET_OF(RawOneByteString, data_));
     return 0;
@@ skipping 30 matching lines @@
                                   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,
                                      Heap::Space space);
 
- private:
-  uint8_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &raw_ptr()->data_[index];
+  static RawOneByteString* ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind);

[siva, 2012/11/02 01:15:25]

Why is this a public method for all other classes this is
a private method with a
friend class SnapshotReader;
declaration.

[Tom Ball, 2012/11/02 23:31:50]

Made private for all four string classes.

+
+  static const ClassId kClassId = kOneByteStringCid;
+
+  static RawOneByteString* null() {
+    return reinterpret_cast<RawOneByteString*>(Object::null());
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(OneByteString, String);
+ private:
+  static uint8_t* CharAddr(const String& str, intptr_t index) {

[siva, 2012/11/02 01:15:25]

The index assertion seems to have been dropped..

Also need an assertion
ASSERT(str.IsOneByteString());

[Tom Ball, 2012/11/02 23:31:50]

Restored old assertion and added new one.

+    NoGCScope no_gc;
+    RawOneByteString* raw_str =
+        reinterpret_cast<RawOneByteString*>(str.raw_ptr());
+    return &raw_str->data_[index];
+  }
+
   friend class Class;
   friend class String;
 };
 
 
 class TwoByteString : public String {

[siva, 2012/11/02 01:15:25]

Ditto comment about this inheriting from String.
Should instead inherit from AllStatic

[Tom Ball, 2012/11/02 23:31:50]

Done.

  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kTwoByteChar;
-  }
-
-  RawTwoByteString* EscapeSpecialCharacters(bool raw_str) const;
+  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;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) == OFFSET_OF(RawTwoByteString, data_));
     return 0;
   }
 
@@ skipping 20 matching lines @@
                                   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,
                                      Heap::Space space);
 
- private:
-  uint16_t* CharAddr(intptr_t index) const {
-    ASSERT((index >= 0) && (index < Length()));
-    return &raw_ptr()->data_[index];
+  static RawTwoByteString* ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind);

[siva, 2012/11/02 01:15:25]

Ditto comment about this being a public method.

[Tom Ball, 2012/11/02 23:31:50]

Done.

+
+  static RawTwoByteString* null() {
+    return reinterpret_cast<RawTwoByteString*>(Object::null());
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(TwoByteString, String);
+  static const ClassId kClassId = kTwoByteStringCid;
+
+ private:
+  static uint16_t* CharAddr(const String& str, intptr_t index) {

[siva, 2012/11/02 01:15:25]

The index assertion seems to have been dropped.

Also need assertion
ASSERT(str.IsTwoByteString());

[Tom Ball, 2012/11/02 23:31:50]

Done.

+    NoGCScope no_gc;
+    RawTwoByteString* raw_str =
+        reinterpret_cast<RawTwoByteString*>(str.raw_ptr());
+    return &raw_str->data_[index];
+  }
+
   friend class Class;
   friend class String;
 };
 
 
 class ExternalOneByteString : public String {

[siva, 2012/11/02 01:15:25]

Ditto comment about inheriting from String, should instead
inherit from AllStatic

[Tom Ball, 2012/11/02 23:31:50]

Done.

- public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+ private:
+  static RawExternalOneByteString* raw_str(const String& str) {
+    return reinterpret_cast<RawExternalOneByteString*>(str.raw_ptr());
   }
 
-  virtual intptr_t CharSize() const {
-    return kOneByteChar;
+ public:
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual bool IsExternal() const { return true; }
-  virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+  static void* GetPeer(const String& str) {
+    return raw_str(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;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalOneByteString));
   }
 
   static RawExternalOneByteString* New(const uint8_t* characters,
                                        intptr_t len,
                                        void* peer,
                                        Dart_PeerFinalizer callback,
                                        Heap::Space space);
 
- private:
-  const uint8_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data()[index]);
+  static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind);

[siva, 2012/11/02 01:15:25]

Ditto comment about this being a public method.

[Tom Ball, 2012/11/02 23:31:50]

Done.

+
+  static RawExternalOneByteString* null() {
+    return reinterpret_cast<RawExternalOneByteString*>(Object::null());
   }
 
-  void SetExternalData(ExternalStringData<uint8_t>* data) {
-    raw_ptr()->external_data_ = data;
+  static const ClassId kClassId = kExternalOneByteStringCid;
+
+ private:
+  static const uint8_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));

[siva, 2012/11/02 01:15:25]

ASSERT(str.IsExternalOneByteString());

[Tom Ball, 2012/11/02 23:31:50]

Done.

+    NoGCScope no_gc;
+    return &(raw_str(str)->external_data_->data()[index]);
+  }
+
+  static void SetExternalData(const String& str,
+                              ExternalStringData<uint8_t>* data) {

[siva, 2012/11/02 01:15:25]

ASSERT(str.IsExternalOneByteString());

[Tom Ball, 2012/11/02 23:31:50]

Done.

+    NoGCScope no_gc;
+    raw_str(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_Handle handle, void* peer);
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalOneByteString, String);
   friend class Class;
   friend class String;
 };
 
 
 class ExternalTwoByteString : public String {

[siva, 2012/11/02 01:15:25]

Ditto comment about inheriting from AllStatic not String.

[Tom Ball, 2012/11/02 23:31:50]

Done.

- public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+ private:
+  static RawExternalTwoByteString* raw_str(const String& str) {
+    return reinterpret_cast<RawExternalTwoByteString*>(str.raw_ptr());
   }
 
-  virtual intptr_t CharSize() const {
-    return kTwoByteChar;
+ public:
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual bool IsExternal() const { return true; }
-  virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+  static void* GetPeer(const String& str) {
+    return raw_str(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;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalTwoByteString));
   }
 
   static RawExternalTwoByteString* New(const uint16_t* characters,
                                        intptr_t len,
                                        void* peer,
                                        Dart_PeerFinalizer callback,
                                        Heap::Space space = Heap::kNew);
 
- private:
-  const uint16_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data()[index]);
+  static RawExternalTwoByteString* ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind);

[siva, 2012/11/02 01:15:25]

Ditto comment about being public.

[Tom Ball, 2012/11/02 23:31:50]

Done.

+
+  static RawExternalTwoByteString* null() {
+    return reinterpret_cast<RawExternalTwoByteString*>(Object::null());
   }
 
-  void SetExternalData(ExternalStringData<uint16_t>* data) {
-    raw_ptr()->external_data_ = data;
+  static const ClassId kClassId = kExternalTwoByteStringCid;
+
+ private:
+  static const uint16_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));

[siva, 2012/11/02 01:15:25]

ASSERT(str.IsExternalTwoByteString());

[Tom Ball, 2012/11/02 23:31:50]

Done.

+    NoGCScope no_gc;
+    return &(raw_str(str)->external_data_->data()[index]);
+  }
+
+  static void SetExternalData(const String& str,
+                              ExternalStringData<uint16_t>* data) {

[siva, 2012/11/02 01:15:25]

ASSERT(str.IsExternalTwoByteString());
NoGCScope no_gc;

[Tom Ball, 2012/11/02 23:31:50]

Done.

+    raw_str(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_Handle handle, void* peer);
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString, String);
   friend class Class;
   friend class String;
 };
 
 
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
   bool value() const {
     return raw_ptr()->value_;
@@ skipping 1702 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_