Correctly recognize external strings.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4691 matching lines @@
 
 int String::Write(uint16_t* buffer,
                   int start,
                   int length,
                   int options) const {
   return WriteHelper(this, buffer, start, length, options);
 }
 
 
 bool v8::String::IsExternal() const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
-  EnsureInitializedForIsolate(str->GetIsolate(), "v8::String::IsExternal()");
-  return i::StringShape(*str).IsExternalTwoByte();
+  i::DisallowHeapAllocation no_gc;
+  i::String* str = *Utils::OpenHandle(this);
+  if (i::StringShape(str).IsCons()) {

[dcarney, 2014/02/04 15:10:05]

extract these 4 lines into a static function

+    i::ConsString* cons = i::ConsString::cast(str);
+    if (cons->second()->length() == 0) str = cons->first();
+  }
+  return i::StringShape(str).IsExternalTwoByte();
 }
 
 
 bool v8::String::IsExternalAscii() const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
-  return i::StringShape(*str).IsExternalAscii();
+  i::DisallowHeapAllocation no_gc;
+  i::String* str = *Utils::OpenHandle(this);
+  if (i::StringShape(str).IsCons()) {
+    i::ConsString* cons = i::ConsString::cast(str);
+    if (cons->second()->length() == 0) str = cons->first();
+  }
+  return i::StringShape(str).IsExternalAscii();
 }
 
 
 void v8::String::VerifyExternalStringResource(
     v8::String::ExternalStringResource* value) const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
+  i::DisallowHeapAllocation no_gc;
+  i::String* str = *Utils::OpenHandle(this);
   const v8::String::ExternalStringResource* expected;
-  if (i::StringShape(*str).IsExternalTwoByte()) {
-    const void* resource =
-        i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
+  if (i::StringShape(str).IsCons()) {
+    i::ConsString* cons = i::ConsString::cast(str);
+    if (cons->second()->length() == 0) str = cons->first();
+  }
+  if (i::StringShape(str).IsExternalTwoByte()) {
+    const void* resource = i::ExternalTwoByteString::cast(str)->resource();
     expected = reinterpret_cast<const ExternalStringResource*>(resource);
   } else {
     expected = NULL;
   }
   CHECK_EQ(expected, value);
 }
 
+
 void v8::String::VerifyExternalStringResourceBase(
     v8::String::ExternalStringResourceBase* value, Encoding encoding) const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
+  i::DisallowHeapAllocation no_gc;
+  i::String* str = *Utils::OpenHandle(this);
   const v8::String::ExternalStringResourceBase* expected;
   Encoding expectedEncoding;
-  if (i::StringShape(*str).IsExternalAscii()) {
-    const void* resource =
-        i::Handle<i::ExternalAsciiString>::cast(str)->resource();
+  if (i::StringShape(str).IsCons()) {
+    i::ConsString* cons = i::ConsString::cast(str);
+    if (cons->second()->length() == 0) str = cons->first();
+  }
+  if (i::StringShape(str).IsExternalAscii()) {
+    const void* resource = i::ExternalAsciiString::cast(str)->resource();
     expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
     expectedEncoding = ASCII_ENCODING;
-  } else if (i::StringShape(*str).IsExternalTwoByte()) {
-    const void* resource =
-        i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
+  } else if (str->IsExternalTwoByteString()) {
+    const void* resource = i::ExternalTwoByteString::cast(str)->resource();
     expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
     expectedEncoding = TWO_BYTE_ENCODING;
   } else {
     expected = NULL;
     expectedEncoding = str->IsOneByteRepresentation() ? ASCII_ENCODING
         : TWO_BYTE_ENCODING;
   }
   CHECK_EQ(expected, value);
   CHECK_EQ(expectedEncoding, encoding);
 }
 
+
+i::Object* v8::String::GetRedirectedString(i::Object* cons) {
+  ASSERT(cons->IsConsString());
+  i::ConsString* cons_string = i::ConsString::cast(cons);
+  if (cons_string->second()->length() == 0) {
+    return cons_string->first();
+  }
+  return cons;
+}
+
+
 const v8::String::ExternalAsciiStringResource*
 v8::String::GetExternalAsciiStringResource() const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
-  if (i::StringShape(*str).IsExternalAscii()) {
-    const void* resource =
-        i::Handle<i::ExternalAsciiString>::cast(str)->resource();
+  i::DisallowHeapAllocation no_gc;
+  i::String* str = *Utils::OpenHandle(this);
+  if (i::StringShape(str).IsCons()) {
+    i::ConsString* cons = i::ConsString::cast(str);
+    if (cons->second()->length() == 0) str = cons->first();
+  }
+  if (i::StringShape(str).IsExternalAscii()) {
+    const void* resource = i::ExternalAsciiString::cast(str)->resource();
     return reinterpret_cast<const ExternalAsciiStringResource*>(resource);
   } else {
     return NULL;
   }
 }
 
 
 Local<Value> Symbol::Name() const {
   i::Handle<i::Symbol> sym = Utils::OpenHandle(this);
   i::Handle<i::Object> name(sym->name(), sym->GetIsolate());
@@ skipping 644 matching lines @@
 static i::Handle<i::String> NewExternalAsciiStringHandle(
     i::Isolate* isolate,
     v8::String::ExternalAsciiStringResource* resource) {
   return isolate->factory()->NewExternalStringFromAscii(resource);
 }
 
 
 static bool RedirectToExternalString(i::Isolate* isolate,
                                      i::Handle<i::String> parent,
                                      i::Handle<i::String> external) {
-  if (parent->IsConsString()) {
-    i::Handle<i::ConsString> cons = i::Handle<i::ConsString>::cast(parent);
-    cons->set_first(*external);
-    cons->set_second(isolate->heap()->empty_string());
-  } else {
-    ASSERT(parent->IsSlicedString());
-    i::Handle<i::SlicedString> slice = i::Handle<i::SlicedString>::cast(parent);
-    slice->set_parent(*external);
-    slice->set_offset(0);
-  }
+  ASSERT(parent->IsConsString() || parent->IsSlicedString());
+  // Replace the map to a cons string of suitable encoding.
+  parent->set_map_no_write_barrier(external->IsOneByteRepresentation()
+      ? isolate->heap()->cons_ascii_string_map()
+      : isolate->heap()->cons_string_map());
+  i::Handle<i::ConsString> cons = i::Handle<i::ConsString>::cast(parent);
+  cons->set_first(*external);
+  cons->set_second(isolate->heap()->empty_string());
   return true;
 }
 
 
 Local<String> v8::String::NewExternal(
     Isolate* isolate,
     v8::String::ExternalStringResource* resource) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   EnsureInitializedForIsolate(i_isolate, "v8::String::NewExternal()");
   LOG_API(i_isolate, "String::NewExternal");
@@ skipping 1940 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal