Unreviewed, rolling out r168254.

Very crashy on debug JSC tests.

Reverted changeset:

"jsSubstring() should be lazy"
https://bugs.webkit.org/show_bug.cgi?id=132556
http://trac.webkit.org/changeset/168254

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@168255 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/runtime/JSString.cpp b/Source/JavaScriptCore/runtime/JSString.cpp
index 5a5e80c..00f05f5 100644
--- a/Source/JavaScriptCore/runtime/JSString.cpp
+++ b/Source/JavaScriptCore/runtime/JSString.cpp
@@ -82,25 +82,14 @@
 
 void JSRopeString::visitFibers(SlotVisitor& visitor)
 {
-    if (isSubstring()) {
-        visitor.append(&substringBase());
-        return;
-    }
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
-        visitor.append(&fiber(i));
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
+        visitor.append(&m_fibers[i]);
 }
 
 void JSRopeString::resolveRope(ExecState* exec) const
 {
     ASSERT(isRope());
-    
-    if (isSubstring()) {
-        ASSERT(!substringBase()->isRope());
-        m_value = substringBase()->m_value.substring(substringOffset(), m_length);
-        substringBase().clear();
-        return;
-    }
-    
+
     if (is8Bit()) {
         LChar* buffer;
         if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
@@ -110,19 +99,19 @@
             outOfMemory(exec);
             return;
         }
-        
-        for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
-            if (fiber(i)->isRope())
+
+        for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
+            if (m_fibers[i]->isRope())
                 return resolveRopeSlowCase8(buffer);
         }
 
         LChar* position = buffer;
-        for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
-            StringImpl* string = fiber(i)->m_value.impl();
+        for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
+            StringImpl* string = m_fibers[i]->m_value.impl();
             unsigned length = string->length();
             StringImpl::copyChars(position, string->characters8(), length);
             position += length;
-            fiber(i).clear();
+            m_fibers[i].clear();
         }
         ASSERT((buffer + m_length) == position);
         ASSERT(!isRope());
@@ -139,21 +128,21 @@
         return;
     }
 
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
-        if (fiber(i)->isRope())
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
+        if (m_fibers[i]->isRope())
             return resolveRopeSlowCase(buffer);
     }
 
     UChar* position = buffer;
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
-        StringImpl* string = fiber(i)->m_value.impl();
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
+        StringImpl* string = m_fibers[i]->m_value.impl();
         unsigned length = string->length();
         if (string->is8Bit())
             StringImpl::copyChars(position, string->characters8(), length);
         else
             StringImpl::copyChars(position, string->characters16(), length);
         position += length;
-        fiber(i).clear();
+        m_fibers[i].clear();
     }
     ASSERT((buffer + m_length) == position);
     ASSERT(!isRope());
@@ -174,35 +163,27 @@
     LChar* position = buffer + m_length; // We will be working backwards over the rope.
     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
     
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
-        workQueue.append(fiber(i).get());
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
+        workQueue.append(m_fibers[i].get());
         // Clearing here works only because there are no GC points in this method.
-        fiber(i).clear();
+        m_fibers[i].clear();
     }
 
     while (!workQueue.isEmpty()) {
         JSString* currentFiber = workQueue.last();
         workQueue.removeLast();
-        
-        const LChar* characters;
-        
+
         if (currentFiber->isRope()) {
             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
-            if (!currentFiberAsRope->isSubstring()) {
-                for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
-                    workQueue.append(currentFiberAsRope->fiber(i).get());
-                continue;
-            }
-            ASSERT(!currentFiberAsRope->substringBase()->isRope());
-            characters =
-                currentFiberAsRope->substringBase()->m_value.characters8() +
-                currentFiberAsRope->substringOffset();
-        } else
-            characters = currentFiber->m_value.characters8();
+            for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
+                workQueue.append(currentFiberAsRope->m_fibers[i].get());
+            continue;
+        }
 
-        unsigned length = currentFiber->length();
+        StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
+        unsigned length = string->length();
         position -= length;
-        StringImpl::copyChars(position, characters, length);
+        StringImpl::copyChars(position, string->characters8(), length);
     }
 
     ASSERT(buffer == position);
@@ -214,8 +195,8 @@
     UChar* position = buffer + m_length; // We will be working backwards over the rope.
     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
 
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
-        workQueue.append(fiber(i).get());
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
+        workQueue.append(m_fibers[i].get());
 
     while (!workQueue.isEmpty()) {
         JSString* currentFiber = workQueue.last();
@@ -223,21 +204,8 @@
 
         if (currentFiber->isRope()) {
             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
-            if (currentFiberAsRope->isSubstring()) {
-                ASSERT(!currentFiberAsRope->substringBase()->isRope());
-                StringImpl* string = static_cast<StringImpl*>(
-                    currentFiberAsRope->substringBase()->m_value.impl());
-                unsigned offset = currentFiberAsRope->substringOffset();
-                unsigned length = currentFiberAsRope->length();
-                position -= length;
-                if (string->is8Bit())
-                    StringImpl::copyChars(position, string->characters8() + offset, length);
-                else
-                    StringImpl::copyChars(position, string->characters16() + offset, length);
-                continue;
-            }
-            for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
-                workQueue.append(currentFiberAsRope->fiber(i).get());
+            for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
+                workQueue.append(currentFiberAsRope->m_fibers[i].get());
             continue;
         }
 
@@ -256,8 +224,8 @@
 
 void JSRopeString::outOfMemory(ExecState* exec) const
 {
-    for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
-        u[i].string.clear();
+    for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
+        m_fibers[i].clear();
     ASSERT(isRope());
     ASSERT(m_value.isNull());
     if (exec)