Allow externalization of canonical strings also. Only restrict canonical strings

vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 2247 matching lines @@
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
+  ASSERT(name.IsOneByteString() || name.IsExternalOneByteString());

[Ivan Posva, 2013/01/17 07:19:39]

I do not understand why we are limiting this to one byte strings here. There is
no code here that expects this symbol to be a one byte string.

Here and many other places.

I am pretty certain that we can end up in these functions with two byte strings
when coming in through the C API.

   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
   Function& function = Function::Handle(isolate, Function::null());
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     intptr_t len = funcs.Length();
     for (intptr_t i = 0; i < len; i++) {
@@ skipping 13 matching lines @@
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
+  ASSERT(name.IsOneByteString() || name.IsExternalOneByteString());
   Array& funcs = Array::Handle(isolate, functions());
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
   Function& function = Function::Handle(isolate, Function::null());
   String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
-    if (OneByteString::EqualsIgnoringPrivateKey(function_name, name)) {
-      return function.raw();
+    if (String::EqualsIgnoringPrivateKey(function_name, name)) {
+        return function.raw();
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
   return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
 }
@@ skipping 72 matching lines @@
     }
     return field.raw();
   }
   // No field found.
   return Field::null();
 }
 
 
 RawField* Class::LookupField(const String& name) const {
   Isolate* isolate = Isolate::Current();
-  ASSERT(name.IsOneByteString());
+  ASSERT(name.IsOneByteString() || name.IsExternalOneByteString());
   const Array& flds = Array::Handle(isolate, fields());
   Field& field = Field::Handle(isolate, Field::null());
   String& field_name = String::Handle(isolate, String::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
-    if (OneByteString::EqualsIgnoringPrivateKey(field_name, name)) {
-      return field.raw();
+    if (String::EqualsIgnoringPrivateKey(field_name, name)) {
+        return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Library& lib = Library::Handle(isolate, library());
@@ skipping 8425 matching lines @@
                                 Dart_PeerFinalizer cback) const {
   NoGCScope no_gc;
   ASSERT(array != NULL);
   intptr_t str_length = this->Length();
   ASSERT(length >= (str_length * this->CharSize()));
   intptr_t class_id = raw()->GetClassId();
   intptr_t used_size = 0;
   intptr_t original_size = 0;
   uword tags = raw_ptr()->tags_;
 
-  ASSERT(!IsCanonical());
+  ASSERT(!InVMHeap());
   if (class_id == kOneByteStringCid) {
     used_size = ExternalOneByteString::InstanceSize();
     original_size = OneByteString::InstanceSize(str_length);
     ASSERT(original_size >= used_size);
 
     // Copy the data into the external array.
     if (str_length > 0) {
       memmove(array, OneByteString::CharAddr(*this, 0), str_length);
     }
 
@@ skipping 76 matching lines @@
   return Transform(CaseMapping::ToUpper, str, space);
 }
 
 
 RawString* String::ToLowerCase(const String& str, Heap::Space space) {
   // TODO(cshapiro): create a fast-path for OneByteString instances.
   return Transform(CaseMapping::ToLower, str, space);
 }
 
 
+// Check to see if 'str1' matches 'str2' as is or
+// once the private key separator is stripped from str2.
+//
+// Things are made more complicated by the fact that constructors are
+// added *after* the private suffix, so "foo@123.named" should match
+// "foo.named".
+//
+// Also, the private suffix can occur more than once in the name, as in:
+//
+//    _ReceivePortImpl@6be832b._internal@6be832b
+//
+template<typename T1, typename T2>
+static bool EqualsIgnoringPrivateKey(const String& str1,
+                                     const String& str2) {
+  NoGCScope no_gc;
+  intptr_t len = str1.Length();
+  intptr_t str2_len = str2.Length();
+  if (len == str2_len) {
+    for (intptr_t i = 0; i < len; i++) {
+      if (T1::CharAt(str1, i) != T2::CharAt(str2, i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (len < str2_len) {
+    return false;  // No way they can match.
+  }
+  intptr_t pos = 0;
+  intptr_t str2_pos = 0;
+  while (pos < len) {
+    int32_t ch = T1::CharAt(str1, pos);
+    pos++;
+
+    if (ch == Scanner::kPrivateKeySeparator) {
+      // Consume a private key separator.
+      while ((pos < len) && (T1::CharAt(str1, pos) != '.')) {
+        pos++;
+      }
+      // Resume matching characters.
+      continue;
+    }
+    if ((str2_pos == str2_len) || (ch != T2::CharAt(str2, str2_pos))) {
+      return false;
+    }
+    str2_pos++;
+  }
+
+  // We have reached the end of mangled_name string.
+  ASSERT(pos == len);
+  return (str2_pos == str2_len);
+}
+
+
+bool String::EqualsIgnoringPrivateKey(const String& str1,
+                                      const String& str2) {
+  if (str1.raw() == str2.raw()) {
+    return true;  // Both handles point to the same raw instance.
+  }
+  if (str1.IsOneByteString()) {
+    if (str2.IsOneByteString()) {
+      return dart::EqualsIgnoringPrivateKey<OneByteString,
+                                            OneByteString>(str1, str2);
+    }
+    ASSERT(str2.IsExternalOneByteString());
+    return dart::EqualsIgnoringPrivateKey<OneByteString,
+                                          ExternalOneByteString>(str1, str2);
+  }
+  ASSERT(str1.IsExternalOneByteString());
+  if (str2.IsOneByteString()) {
+    return dart::EqualsIgnoringPrivateKey<ExternalOneByteString,
+                                          OneByteString>(str1, str2);
+  }
+  ASSERT(str2.IsExternalOneByteString());
+  return dart::EqualsIgnoringPrivateKey<ExternalOneByteString,
+                                        ExternalOneByteString>(str1, str2);
+}
+
+
 bool String::CodePointIterator::Next() {
   ASSERT(index_ >= -1);
   intptr_t length = Utf16::Length(ch_);
   if (index_ < (end_ - length)) {
     index_ += length;
     ch_ = str_.CharAt(index_);
     if (Utf16::IsLeadSurrogate(ch_) && (index_ < (end_ - 1))) {
       int32_t ch2 = str_.CharAt(index_ + 1);
       if (Utf16::IsTrailSurrogate(ch2)) {
         ch_ = Utf16::Decode(ch_, ch2);
@@ skipping 33 matching lines @@
         *(CharAddr(dststr, index)) = *CharAddr(str, i);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::null();
 }
 
 
-// Check to see if 'str1' matches 'str2' as is or
-// once the private key separator is stripped from str2.
-//
-// Things are made more complicated by the fact that constructors are
-// added *after* the private suffix, so "foo@123.named" should match
-// "foo.named".
-//
-// Also, the private suffix can occur more than once in the name, as in:
-//
-//    _ReceivePortImpl@6be832b._internal@6be832b
-//
-bool OneByteString::EqualsIgnoringPrivateKey(const String& str1,
-                                             const String& str2) {
-  ASSERT(str2.IsOneByteString());
-  if (str1.raw() == str2.raw()) {
-    return true;  // Both handles point to the same raw instance.
-  }
-  NoGCScope no_gc;
-  intptr_t len = str1.Length();
-  intptr_t str2_len = str2.Length();
-  if (len == str2_len) {
-    for (intptr_t i = 0; i < len; i++) {
-      if (*CharAddr(str1, i) != *CharAddr(str2, i)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (len < str2_len) {
-    return false;  // No way they can match.
-  }
-  intptr_t pos = 0;
-  intptr_t str2_pos = 0;
-  while (pos < len) {
-    int32_t ch = *CharAddr(str1, pos);
-    pos++;
-
-    if (ch == Scanner::kPrivateKeySeparator) {
-      // Consume a private key separator.
-      while ((pos < len) && (*CharAddr(str1, pos) != '.')) {
-        pos++;
-      }
-      // Resume matching characters.
-      continue;
-    }
-    if ((str2_pos == str2_len) || (ch != *CharAddr(str2, str2_pos))) {
-      return false;
-    }
-    str2_pos++;
-  }
-
-  // We have reached the end of mangled_name string.
-  ASSERT(pos == len);
-  return (str2_pos == str2_len);
-}
-
-
 RawOneByteString* OneByteString::New(intptr_t len,
                                      Heap::Space space) {
   ASSERT(Isolate::Current() == Dart::vm_isolate() ||
          Isolate::Current()->object_store()->one_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %"Pd"\n", len);
   }
   String& result = String::Handle();
@@ skipping 1515 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart