Implement external strings.

runtime/vm/object.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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 447 matching lines @@
   cls = Class::New<TwoByteString>();
   object_store->set_two_byte_string_class(cls);
   RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
   cls = Class::New<FourByteString>();
   object_store->set_four_byte_string_class(cls);
   RegisterClass(cls, "FourByteString", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
+  cls = Class::New<ExternalOneByteString>();
+  object_store->set_external_one_byte_string_class(cls);
+  RegisterClass(cls, "ExternalOneByteString", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+
+  cls = Class::New<ExternalTwoByteString>();
+  object_store->set_external_two_byte_string_class(cls);
+  RegisterClass(cls, "ExternalTwoByteString", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+
+  cls = Class::New<ExternalFourByteString>();
+  object_store->set_external_four_byte_string_class(cls);
+  RegisterClass(cls, "ExternalFourByteString", impl_script, core_impl_lib);
+  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
+
   cls = Class::New<UnhandledException>();
   object_store->set_unhandled_exception_class(cls);
   RegisterClass(cls, "UnhandledException", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
   RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   // Super type set below, after Object is allocated.
@@ skipping 155 matching lines @@
 
   cls = Class::New<OneByteString>();
   object_store->set_one_byte_string_class(cls);
 
   cls = Class::New<TwoByteString>();
   object_store->set_two_byte_string_class(cls);
 
   cls = Class::New<FourByteString>();
   object_store->set_four_byte_string_class(cls);
 
+  cls = Class::New<ExternalOneByteString>();
+  object_store->set_external_one_byte_string_class(cls);
+
+  cls = Class::New<ExternalTwoByteString>();
+  object_store->set_external_two_byte_string_class(cls);
+
+  cls = Class::New<ExternalFourByteString>();
+  object_store->set_external_four_byte_string_class(cls);
+
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
   cls = Class::New<UnhandledException>();
   object_store->set_unhandled_exception_class(cls);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
 
   cls = Class::New<JSRegExp>();
@@ skipping 478 matching lines @@
       return object_store->double_class();
     case kOneByteString:
       ASSERT(object_store->one_byte_string_class() != Class::null());
       return object_store->one_byte_string_class();
     case kTwoByteString:
       ASSERT(object_store->two_byte_string_class() != Class::null());
       return object_store->two_byte_string_class();
     case kFourByteString:
       ASSERT(object_store->four_byte_string_class() != Class::null());
       return object_store->four_byte_string_class();
+    case kExternalOneByteString:
+      ASSERT(object_store->external_one_byte_string_class() != Class::null());
+      return object_store->external_one_byte_string_class();
+    case kExternalTwoByteString:
+      ASSERT(object_store->external_two_byte_string_class() != Class::null());
+      return object_store->external_two_byte_string_class();
+    case kExternalFourByteString:
+      ASSERT(object_store->external_four_byte_string_class() != Class::null());
+      return object_store->external_four_byte_string_class();
     case kBool:
       ASSERT(object_store->bool_class() != Class::null());
       return object_store->bool_class();
     case kArray:
       ASSERT(object_store->array_class() != Class::null());
       return object_store->array_class();
     case kImmutableArray:
       ASSERT(object_store->immutable_array_class() != Class::null());
       return object_store->immutable_array_class();
     case kByteBuffer:
@@ skipping 4433 matching lines @@
 }
 
 
 int32_t String::CharAt(intptr_t index) const {
   // String is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
 
+intptr_t String::CharSize() const {
+  // String is an abstract class.
+  UNREACHABLE();
+  return 0;
+}
+
+
 bool String::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   if (!other.IsString() || other.IsNull()) {
     return false;
   }
 
@@ skipping 243 matching lines @@
   }
   return FourByteString::New(characters, len, space);
 }
 
 
 RawString* String::New(const String& str, Heap::Space space) {
   // Currently this just creates a copy of the string in the correct space.
   // Once we have external string support, this will also create a heap copy of
   // the string if necessary. Some optimizations are possible, such as not
   // copying internal strings into the same space.
-  if (str.IsOneByteString()) {
-    OneByteString& one_byte_str = OneByteString::Handle();
-    one_byte_str ^= str.raw();
-    return OneByteString::New(one_byte_str, space);
-  } else if (str.IsTwoByteString()) {
-    TwoByteString& two_byte_str = TwoByteString::Handle();
-    two_byte_str ^= str.raw();
-    return TwoByteString::New(two_byte_str, space);
+  intptr_t len = str.Length();
+  String& result = String::Handle();
+  intptr_t char_size = str.CharSize();
+  if (char_size == kOneByteChar) {
+    result ^= OneByteString::New(len, space);
+  } else if (char_size == kTwoByteChar) {
+    result ^= TwoByteString::New(len, space);
+  } else {
+    ASSERT(char_size == kFourByteChar);
+    result ^= FourByteString::New(len, space);
   }
-  ASSERT(str.IsFourByteString());
-  FourByteString& four_byte_str = FourByteString::Handle();
-  four_byte_str ^= str.raw();
-  return FourByteString::New(four_byte_str, space);
+  String::Copy(result, 0, str, 0, len);
+  return result.raw();
 }
 
 
+RawString* String::NewExternal(const uint8_t* characters,
+                               intptr_t len,
+                               void* peer,
+                               PeerFinalizer callback,
+                               Heap::Space space) {
+  return ExternalOneByteString::New(characters, len, peer, callback, space);
+}
+
+
+RawString* String::NewExternal(const uint16_t* characters,
+                               intptr_t len,
+                               void* peer,
+                               PeerFinalizer callback,
+                               Heap::Space space) {
+  return ExternalTwoByteString::New(characters, len, peer, callback, space);
+}
+
+
+RawString* String::NewExternal(const uint32_t* characters,
+                               intptr_t len,
+                               void* peer,
+                               PeerFinalizer callback,
+                               Heap::Space space) {
+  return ExternalFourByteString::New(characters, len, peer, callback, space);
+}
+
+
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const uint8_t* characters,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   if (dst.IsOneByteString()) {
     OneByteString& onestr = OneByteString::Handle();
     onestr ^= dst.raw();
     NoGCScope no_gc;
@@ skipping 88 matching lines @@
 
 void String::Copy(const String& dst, intptr_t dst_offset,
                   const String& src, intptr_t src_offset,
                   intptr_t len) {
   ASSERT(dst_offset >= 0);
   ASSERT(src_offset >= 0);
   ASSERT(len >= 0);
   ASSERT(len <= (dst.Length() - dst_offset));
   ASSERT(len <= (src.Length() - src_offset));
   if (len > 0) {
-    if (src.IsOneByteString()) {
-      OneByteString& onestr = OneByteString::Handle();
-      onestr ^= src.raw();
-      NoGCScope no_gc;
-      String::Copy(dst, dst_offset, onestr.CharAddr(0) + src_offset, len);
-    } else if (src.IsTwoByteString()) {
-      TwoByteString& twostr = TwoByteString::Handle();
-      twostr ^= src.raw();
-      NoGCScope no_gc;
-      String::Copy(dst, dst_offset, twostr.CharAddr(0) + src_offset, len);
+    intptr_t char_size = src.CharSize();
+    if (char_size == kOneByteChar) {
+      if (src.IsOneByteString()) {
+        OneByteString& onestr = OneByteString::Handle();
+        onestr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, onestr.CharAddr(0) + src_offset, len);
+      } else {
+        ASSERT(src.IsExternalOneByteString());
+        ExternalOneByteString& onestr = ExternalOneByteString::Handle();
+        onestr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, onestr.CharAddr(0) + src_offset, len);
+      }
+    } else if (char_size == kTwoByteChar) {
+      if (src.IsTwoByteString()) {
+        TwoByteString& twostr = TwoByteString::Handle();
+        twostr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, twostr.CharAddr(0) + src_offset, len);
+      } else {
+        ASSERT(src.IsExternalTwoByteString());
+        ExternalTwoByteString& twostr = ExternalTwoByteString::Handle();
+        twostr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, twostr.CharAddr(0) + src_offset, len);
+      }
     } else {
-      ASSERT(src.IsFourByteString());
-      FourByteString& fourstr = FourByteString::Handle();
-      fourstr ^= src.raw();
-      NoGCScope no_gc;
-      String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
+      ASSERT(char_size == kFourByteChar);
+      if (src.IsFourByteString()) {
+        FourByteString& fourstr = FourByteString::Handle();
+        fourstr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
+      } else {
+        ASSERT(src.IsExternalFourByteString());
+        ExternalFourByteString& fourstr = ExternalFourByteString::Handle();
+        fourstr ^= src.raw();
+        NoGCScope no_gc;
+        String::Copy(dst, dst_offset, fourstr.CharAddr(0) + src_offset, len);
+      }
     }
   }
 }
 
 
 static void GrowSymbolTable(const Array& symbol_table, intptr_t table_size) {
   // TODO(iposva): Avoid exponential growth.
   intptr_t new_table_size = table_size * 2;
   Array& new_symbol_table = Array::Handle(Array::New(new_table_size + 1));
   // Copy all elements from the original symbol table to the newly allocated
@@ skipping 141 matching lines @@
   }
   ASSERT(symbol.IsSymbol());
   return symbol.raw();
 }
 
 
 RawString* String::Concat(const String& str1,
                           const String& str2,
                           Heap::Space space) {
   ASSERT(!str1.IsNull() && !str2.IsNull());
-  if (str1.IsFourByteString() || str2.IsFourByteString()) {
+  intptr_t char_size = Utils::Maximum(str1.CharSize(), str2.CharSize());
+  if (char_size == kFourByteChar) {
     return FourByteString::Concat(str1, str2, space);
   }
-  if (str1.IsTwoByteString() || str2.IsTwoByteString()) {
+  if (char_size == kTwoByteChar) {
     return TwoByteString::Concat(str1, str2, space);
   }
-  ASSERT(str1.IsOneByteString() && str2.IsOneByteString());
   return OneByteString::Concat(str1, str2, space);
 }
 
 
 RawString* String::ConcatAll(const Array& strings,
                              Heap::Space space) {
   ASSERT(!strings.IsNull());
-  bool is_one_byte_string = true;
-  bool is_two_byte_string = true;
   intptr_t result_len = 0;
   intptr_t strings_len = strings.Length();
   String& str = String::Handle();
+  intptr_t char_size = kOneByteChar;
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     result_len += str.Length();
-    if (str.IsFourByteString()) {
-      is_one_byte_string = false;
-      is_two_byte_string = false;
-    } else if (str.IsTwoByteString()) {
-      is_one_byte_string = false;
-    }
+    char_size = Utils::Maximum(char_size, str.CharSize());
   }
-  if (is_one_byte_string) {
+  if (char_size == kOneByteChar) {
     return OneByteString::ConcatAll(strings, result_len, space);
-  } else if (is_two_byte_string) {
+  } else if (char_size == kTwoByteChar) {
     return TwoByteString::ConcatAll(strings, result_len, space);
   }
+  ASSERT(char_size == kFourByteChar);
   return FourByteString::ConcatAll(strings, result_len, space);
 }
 
 
 RawString* String::SubString(const String& str,
                              intptr_t begin_index,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   if (begin_index >= str.Length()) {
     return String::null();
   }
   return String::SubString(str, begin_index, (str.Length() - begin_index));
 }
 
 
 RawString* String::SubString(const String& str,
                              intptr_t begin_index,
                              intptr_t length,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index >= str.Length()) {
     return String::null();
   }
-  if (str.IsOneByteString()) {
-    OneByteString& obstr = OneByteString::Handle();
-    obstr ^= str.raw();
-    return OneByteString::SubString(obstr, begin_index, length, space);
-  } else if (str.IsTwoByteString()) {
-    TwoByteString& twostr = TwoByteString::Handle();
-    twostr ^= str.raw();
-    return TwoByteString::SubString(twostr, begin_index, length, space);
+  String& result = String::Handle();
+  bool is_one_byte_string = true;
+  bool is_two_byte_string = true;
+  intptr_t char_size = str.CharSize();
+  if (char_size == kTwoByteChar) {
+    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
+      if (str.CharAt(i) > 0xFF) {
+        is_one_byte_string = false;
+        break;
+      }
+    }
+  } else if (char_size == kFourByteChar) {
+    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
+      if (str.CharAt(i) > 0xFFFF) {
+        is_one_byte_string = false;
+        is_two_byte_string = false;
+        break;
+      } else if (str.CharAt(i) > 0xFF) {
+        is_one_byte_string = false;
+      }
+    }
   }
-  ASSERT(str.IsFourByteString());
-  FourByteString& fourstr = FourByteString::Handle();
-  fourstr ^= str.raw();
-  return FourByteString::SubString(fourstr, begin_index, length, space);
+  if (is_one_byte_string) {
+    result ^= OneByteString::New(length, space);
+  } else if (is_two_byte_string) {
+    result ^= TwoByteString::New(length, space);
+  } else {
+    result ^= FourByteString::New(length, space);
+  }
+  String::Copy(result, 0, str, begin_index, length);
+  return result.raw();
 }
 
 
 const char* String::ToCString() const {
   intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
   char* result = reinterpret_cast<char*>(zone->Allocate(len + 1));
   Utf8::Encode(*this, result, len);
   result[len] = 0;
   return result;
@@ skipping 127 matching lines @@
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
 }
 
 
-RawString* OneByteString::SubString(const OneByteString& str,
-                                    intptr_t begin_index,
-                                    intptr_t length,
-                                    Heap::Space space) {
-  ASSERT(!str.IsNull());
-  ASSERT(begin_index < str.Length());
-  OneByteString& result = OneByteString::Handle();
-  if (length <= (str.Length() - begin_index)) {
-    result ^= OneByteString::New(length, space);
-    String::Copy(result, 0, str, begin_index, length);
-  }
-  // TODO(5418937): return a non-null object on error.
-  return result.raw();
-}
-
-
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const OneByteString& result =
       OneByteString::Handle(OneByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(ch >= 0 && ch <= 0xFF);
@@ skipping 83 matching lines @@
   for (intptr_t i = 0; i < strings_len; i++) {
     str ^= strings.At(i);
     intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     pos += str_len;
   }
   return result.raw();
 }
 
 
-RawString* TwoByteString::SubString(const TwoByteString& str,
-                                    intptr_t begin_index,
-                                    intptr_t length,
-                                    Heap::Space space) {
-  ASSERT(!str.IsNull());
-  ASSERT(begin_index < str.Length());
-  String& result = String::Handle();
-  if (length <= (str.Length() - begin_index)) {
-    bool is_one_byte_string = true;
-    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
-      if (str.CharAt(i) > 0xFF) {
-        is_one_byte_string = false;
-        break;
-      }
-    }
-    if (is_one_byte_string) {
-      result ^= OneByteString::New(length, space);
-    } else {
-      result ^= TwoByteString::New(length, space);
-    }
-    String::Copy(result, 0, str, begin_index, length);
-  }
-  // TODO(5418937): return a non-null object on error.
-  return result.raw();
-}
-
-
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const TwoByteString& result =
       TwoByteString::Handle(TwoByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(ch >= 0 && ch <= 0xFFFF);
@@ skipping 71 matching lines @@
       str ^= strings.At(i);
       intptr_t str_len = str.Length();
       String::Copy(result, pos, str, 0, str_len);
       pos += str_len;
     }
   }
   return result.raw();
 }
 
 
-RawString* FourByteString::SubString(const FourByteString& str,
-                                     intptr_t begin_index,
-                                     intptr_t length,
-                                     Heap::Space space) {
-  ASSERT(!str.IsNull());
-  ASSERT(begin_index < str.Length());
-  String& result = String::Handle();
-  if (length <= (str.Length() - begin_index)) {
-    bool is_one_byte_string = true;
-    bool is_two_byte_string = true;
-    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
-      if (str.CharAt(i) > 0xFFFF) {
-        is_one_byte_string = false;
-        is_two_byte_string = false;
-        break;
-      } else if (str.CharAt(i) > 0xFF) {
-        is_one_byte_string = false;
-      }
-    }
-    if (is_one_byte_string) {
-      result ^= OneByteString::New(length, space);
-    } else if (is_two_byte_string) {
-      result ^= TwoByteString::New(length, space);
-    } else {
-      result ^= FourByteString::New(length, space);
-    }
-    String::Copy(result, 0, str, begin_index, length);
-  }
-  // TODO(5418937): return a non-null object on error.
-  return result.raw();
-}
-
-
 RawFourByteString* FourByteString::Transform(int32_t (*mapping)(int32_t ch),
                                              const String& str,
                                              Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const FourByteString& result =
       FourByteString::Handle(FourByteString::New(len, space));
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(ch >= 0 && ch <= 0x10FFFF);
     *result.CharAddr(i) = ch;
   }
   return result.raw();
 }
 
 
 const char* FourByteString::ToCString() const {
   return String::ToCString();
 }
 
 
+RawExternalOneByteString* ExternalOneByteString::New(const uint8_t* data,
+                                                     intptr_t len,
+                                                     void* peer,
+                                                     PeerFinalizer callback,
+                                                     Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_one_byte_string_class());
+  ExternalOneByteString& result = ExternalOneByteString::Handle();
+  {
+    ExternalStringData<uint8_t>* external_data =
+        new ExternalStringData<uint8_t>(data, peer, callback);
+    RawObject* raw = Object::Allocate(cls,
+                                      ExternalOneByteString::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
+    result.SetHash(0);
+    result.SetExternalData(external_data);
+  }
+  return result.raw();
+}
+
+
+const char* ExternalOneByteString::ToCString() const {
+  return String::ToCString();
+}
+
+
+RawExternalTwoByteString* ExternalTwoByteString::New(const uint16_t* data,
+                                                     intptr_t len,
+                                                     void* peer,
+                                                     PeerFinalizer callback,
+                                                     Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_two_byte_string_class());
+  ExternalTwoByteString& result = ExternalTwoByteString::Handle();
+  {
+    ExternalStringData<uint16_t>* external_data =
+        new ExternalStringData<uint16_t>(data, peer, callback);
+    RawObject* raw = Object::Allocate(cls,
+                                      ExternalTwoByteString::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
+    result.SetHash(0);
+    result.SetExternalData(external_data);
+  }
+  return result.raw();
+}
+
+
+const char* ExternalTwoByteString::ToCString() const {
+  return String::ToCString();
+}
+
+
+RawExternalFourByteString* ExternalFourByteString::New(const uint32_t* data,
+                                                       intptr_t len,
+                                                       void* peer,
+                                                       PeerFinalizer callback,
+                                                       Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+
+  const Class& cls =
+      Class::Handle(isolate->object_store()->external_four_byte_string_class());
+  ExternalFourByteString& result = ExternalFourByteString::Handle();
+  {
+    ExternalStringData<uint32_t>* external_data =
+        new ExternalStringData<uint32_t>(data, peer, callback);
+    RawObject* raw = Object::Allocate(cls,
+                                      ExternalFourByteString::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
+    result.SetHash(0);
+    result.SetExternalData(external_data);
+  }
+  return result.raw();
+}
+
+
+const char* ExternalFourByteString::ToCString() const {
+  return String::ToCString();
+}
+
+
 RawBool* Bool::True() {
   return Isolate::Current()->object_store()->true_value();
 }
 
 
 RawBool* Bool::False() {
   return Isolate::Current()->object_store()->false_value();
 }
 
 
@@ skipping 467 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart