Unreviewed, rolling out r168254.
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSString.cpp
1 /*
2  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2004, 2007, 2008 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24 #include "JSString.h"
25
26 #include "JSGlobalObject.h"
27 #include "JSGlobalObjectFunctions.h"
28 #include "JSObject.h"
29 #include "JSCInlines.h"
30 #include "StringObject.h"
31 #include "StringPrototype.h"
32
33 namespace JSC {
34     
35 const ClassInfo JSString::s_info = { "string", 0, 0, 0, CREATE_METHOD_TABLE(JSString) };
36
37 void JSRopeString::RopeBuilder::expand()
38 {
39     ASSERT(m_index == JSRopeString::s_maxInternalRopeLength);
40     JSString* jsString = m_jsString;
41     RELEASE_ASSERT(jsString);
42     m_jsString = jsStringBuilder(&m_vm);
43     m_index = 0;
44     append(jsString);
45 }
46
47 void JSString::destroy(JSCell* cell)
48 {
49     JSString* thisObject = static_cast<JSString*>(cell);
50     thisObject->JSString::~JSString();
51 }
52
53 void JSString::dumpToStream(const JSCell* cell, PrintStream& out)
54 {
55     const JSString* thisObject = jsCast<const JSString*>(cell);
56     out.printf("<%p, %s, [%u], ", thisObject, thisObject->className(), thisObject->length()); 
57     if (thisObject->isRope())
58         out.printf("[rope]");
59     else {
60         WTF::StringImpl* ourImpl = thisObject->m_value.impl();
61         if (ourImpl->is8Bit())
62             out.printf("[8 %p]", ourImpl->characters8());
63         else
64             out.printf("[16 %p]", ourImpl->characters16());
65     }
66     out.printf(">");
67 }
68
69 void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
70 {
71     JSString* thisObject = jsCast<JSString*>(cell);
72     Base::visitChildren(thisObject, visitor);
73     
74     if (thisObject->isRope())
75         static_cast<JSRopeString*>(thisObject)->visitFibers(visitor);
76     else {
77         StringImpl* impl = thisObject->m_value.impl();
78         ASSERT(impl);
79         visitor.reportExtraMemoryUsage(thisObject, impl->costDuringGC());
80     }
81 }
82
83 void JSRopeString::visitFibers(SlotVisitor& visitor)
84 {
85     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
86         visitor.append(&m_fibers[i]);
87 }
88
89 void JSRopeString::resolveRope(ExecState* exec) const
90 {
91     ASSERT(isRope());
92
93     if (is8Bit()) {
94         LChar* buffer;
95         if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
96             Heap::heap(this)->reportExtraMemoryCost(newImpl->cost());
97             m_value = newImpl.release();
98         } else {
99             outOfMemory(exec);
100             return;
101         }
102
103         for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
104             if (m_fibers[i]->isRope())
105                 return resolveRopeSlowCase8(buffer);
106         }
107
108         LChar* position = buffer;
109         for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
110             StringImpl* string = m_fibers[i]->m_value.impl();
111             unsigned length = string->length();
112             StringImpl::copyChars(position, string->characters8(), length);
113             position += length;
114             m_fibers[i].clear();
115         }
116         ASSERT((buffer + m_length) == position);
117         ASSERT(!isRope());
118
119         return;
120     }
121
122     UChar* buffer;
123     if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
124         Heap::heap(this)->reportExtraMemoryCost(newImpl->cost());
125         m_value = newImpl.release();
126     } else {
127         outOfMemory(exec);
128         return;
129     }
130
131     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
132         if (m_fibers[i]->isRope())
133             return resolveRopeSlowCase(buffer);
134     }
135
136     UChar* position = buffer;
137     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
138         StringImpl* string = m_fibers[i]->m_value.impl();
139         unsigned length = string->length();
140         if (string->is8Bit())
141             StringImpl::copyChars(position, string->characters8(), length);
142         else
143             StringImpl::copyChars(position, string->characters16(), length);
144         position += length;
145         m_fibers[i].clear();
146     }
147     ASSERT((buffer + m_length) == position);
148     ASSERT(!isRope());
149 }
150
151 // Overview: These functions convert a JSString from holding a string in rope form
152 // down to a simple String representation. It does so by building up the string
153 // backwards, since we want to avoid recursion, we expect that the tree structure
154 // representing the rope is likely imbalanced with more nodes down the left side
155 // (since appending to the string is likely more common) - and as such resolving
156 // in this fashion should minimize work queue size.  (If we built the queue forwards
157 // we would likely have to place all of the constituent StringImpls into the
158 // Vector before performing any concatenation, but by working backwards we likely
159 // only fill the queue with the number of substrings at any given level in a
160 // rope-of-ropes.)    
161 void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const
162 {
163     LChar* position = buffer + m_length; // We will be working backwards over the rope.
164     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
165     
166     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
167         workQueue.append(m_fibers[i].get());
168         // Clearing here works only because there are no GC points in this method.
169         m_fibers[i].clear();
170     }
171
172     while (!workQueue.isEmpty()) {
173         JSString* currentFiber = workQueue.last();
174         workQueue.removeLast();
175
176         if (currentFiber->isRope()) {
177             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
178             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
179                 workQueue.append(currentFiberAsRope->m_fibers[i].get());
180             continue;
181         }
182
183         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
184         unsigned length = string->length();
185         position -= length;
186         StringImpl::copyChars(position, string->characters8(), length);
187     }
188
189     ASSERT(buffer == position);
190     ASSERT(!isRope());
191 }
192
193 void JSRopeString::resolveRopeSlowCase(UChar* buffer) const
194 {
195     UChar* position = buffer + m_length; // We will be working backwards over the rope.
196     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
197
198     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
199         workQueue.append(m_fibers[i].get());
200
201     while (!workQueue.isEmpty()) {
202         JSString* currentFiber = workQueue.last();
203         workQueue.removeLast();
204
205         if (currentFiber->isRope()) {
206             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
207             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->m_fibers[i]; ++i)
208                 workQueue.append(currentFiberAsRope->m_fibers[i].get());
209             continue;
210         }
211
212         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
213         unsigned length = string->length();
214         position -= length;
215         if (string->is8Bit())
216             StringImpl::copyChars(position, string->characters8(), length);
217         else
218             StringImpl::copyChars(position, string->characters16(), length);
219     }
220
221     ASSERT(buffer == position);
222     ASSERT(!isRope());
223 }
224
225 void JSRopeString::outOfMemory(ExecState* exec) const
226 {
227     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
228         m_fibers[i].clear();
229     ASSERT(isRope());
230     ASSERT(m_value.isNull());
231     if (exec)
232         throwOutOfMemoryError(exec);
233 }
234
235 JSString* JSRopeString::getIndexSlowCase(ExecState* exec, unsigned i)
236 {
237     ASSERT(isRope());
238     resolveRope(exec);
239     // Return a safe no-value result, this should never be used, since the excetion will be thrown.
240     if (exec->exception())
241         return jsEmptyString(exec);
242     ASSERT(!isRope());
243     RELEASE_ASSERT(i < m_value.length());
244     return jsSingleCharacterSubstring(exec, m_value, i);
245 }
246
247 JSValue JSString::toPrimitive(ExecState*, PreferredPrimitiveType) const
248 {
249     return const_cast<JSString*>(this);
250 }
251
252 bool JSString::getPrimitiveNumber(ExecState* exec, double& number, JSValue& result) const
253 {
254     result = this;
255     number = jsToNumber(value(exec));
256     return false;
257 }
258
259 bool JSString::toBoolean() const
260 {
261     return m_length;
262 }
263
264 double JSString::toNumber(ExecState* exec) const
265 {
266     return jsToNumber(value(exec));
267 }
268
269 inline StringObject* StringObject::create(VM& vm, JSGlobalObject* globalObject, JSString* string)
270 {
271     StringObject* object = new (NotNull, allocateCell<StringObject>(vm.heap)) StringObject(vm, globalObject->stringObjectStructure());
272     object->finishCreation(vm, string);
273     return object;
274 }
275
276 JSObject* JSString::toObject(ExecState* exec, JSGlobalObject* globalObject) const
277 {
278     return StringObject::create(exec->vm(), globalObject, const_cast<JSString*>(this));
279 }
280
281 JSValue JSString::toThis(JSCell* cell, ExecState* exec, ECMAMode ecmaMode)
282 {
283     if (ecmaMode == StrictMode)
284         return cell;
285     return StringObject::create(exec->vm(), exec->lexicalGlobalObject(), jsCast<JSString*>(cell));
286 }
287
288 bool JSString::getStringPropertyDescriptor(ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
289 {
290     if (propertyName == exec->propertyNames().length) {
291         descriptor.setDescriptor(jsNumber(m_length), DontEnum | DontDelete | ReadOnly);
292         return true;
293     }
294     
295     unsigned i = propertyName.asIndex();
296     if (i < m_length) {
297         ASSERT(i != PropertyName::NotAnIndex); // No need for an explicit check, the above test would always fail!
298         descriptor.setDescriptor(getIndex(exec, i), DontDelete | ReadOnly);
299         return true;
300     }
301     
302     return false;
303 }
304
305 } // namespace JSC