De-virtualize destructors
[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 "Operations.h"
30 #include "StringObject.h"
31 #include "StringPrototype.h"
32
33 namespace JSC {
34     
35 static const unsigned substringFromRopeCutoff = 4;
36
37 const ClassInfo JSString::s_info = { "string", 0, 0, 0, CREATE_METHOD_TABLE(JSString) };
38
39 void JSString::RopeBuilder::expand()
40 {
41     ASSERT(m_index == JSString::s_maxInternalRopeLength);
42     JSString* jsString = m_jsString;
43     m_jsString = jsStringBuilder(&m_globalData);
44     m_index = 0;
45     append(jsString);
46 }
47
48 void JSString::destroy(JSCell* cell)
49 {
50     JSString* thisObject = jsCast<JSString*>(cell);
51     thisObject->JSString::~JSString();
52 }
53
54 void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
55 {
56     JSString* thisObject = jsCast<JSString*>(cell);
57     Base::visitChildren(thisObject, visitor);
58     for (size_t i = 0; i < s_maxInternalRopeLength && thisObject->m_fibers[i]; ++i)
59         visitor.append(&thisObject->m_fibers[i]);
60 }
61
62 void JSString::resolveRope(ExecState* exec) const
63 {
64     ASSERT(isRope());
65
66     if (is8Bit()) {
67         LChar* buffer;
68         if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer))
69             m_value = newImpl.release();
70         else {
71             outOfMemory(exec);
72             return;
73         }
74
75         for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
76             if (m_fibers[i]->isRope())
77                 return resolveRopeSlowCase8(buffer);
78         }
79
80         LChar* position = buffer;
81         for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
82             StringImpl* string = m_fibers[i]->m_value.impl();
83             unsigned length = string->length();
84             StringImpl::copyChars(position, string->characters8(), length);
85             position += length;
86             m_fibers[i].clear();
87         }
88         ASSERT((buffer + m_length) == position);
89         ASSERT(!isRope());
90
91         return;
92     }
93
94     UChar* buffer;
95     if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer))
96         m_value = newImpl.release();
97     else {
98         outOfMemory(exec);
99         return;
100     }
101
102     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
103         if (m_fibers[i]->isRope())
104             return resolveRopeSlowCase(buffer);
105     }
106
107     UChar* position = buffer;
108     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
109         StringImpl* string = m_fibers[i]->m_value.impl();
110         unsigned length = string->length();
111         StringImpl::copyChars(position, string->characters(), length);
112         position += length;
113         m_fibers[i].clear();
114     }
115     ASSERT((buffer + m_length) == position);
116     ASSERT(!isRope());
117 }
118
119 // Overview: These functions convert a JSString from holding a string in rope form
120 // down to a simple UString representation.  It does so by building up the string
121 // backwards, since we want to avoid recursion, we expect that the tree structure
122 // representing the rope is likely imbalanced with more nodes down the left side
123 // (since appending to the string is likely more common) - and as such resolving
124 // in this fashion should minimize work queue size.  (If we built the queue forwards
125 // we would likely have to place all of the constituent StringImpls into the
126 // Vector before performing any concatenation, but by working backwards we likely
127 // only fill the queue with the number of substrings at any given level in a
128 // rope-of-ropes.)    
129 void JSString::resolveRopeSlowCase8(LChar* buffer) const
130 {
131     LChar* position = buffer + m_length; // We will be working backwards over the rope.
132     Vector<JSString*, 32> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
133     
134     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
135         workQueue.append(m_fibers[i].get());
136         // Clearing here works only because there are no GC points in this method.
137         m_fibers[i].clear();
138     }
139
140     while (!workQueue.isEmpty()) {
141         JSString* currentFiber = workQueue.last();
142         workQueue.removeLast();
143
144         if (currentFiber->isRope()) {
145             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiber->m_fibers[i]; ++i)
146                 workQueue.append(currentFiber->m_fibers[i].get());
147             continue;
148         }
149
150         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
151         unsigned length = string->length();
152         position -= length;
153         StringImpl::copyChars(position, string->characters8(), length);
154     }
155
156     ASSERT(buffer == position);
157     ASSERT(!isRope());
158 }
159
160 void JSString::resolveRopeSlowCase(UChar* buffer) const
161 {
162     UChar* position = buffer + m_length; // We will be working backwards over the rope.
163     Vector<JSString*, 32> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
164
165     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
166         workQueue.append(m_fibers[i].get());
167
168     while (!workQueue.isEmpty()) {
169         JSString* currentFiber = workQueue.last();
170         workQueue.removeLast();
171
172         if (currentFiber->isRope()) {
173             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiber->m_fibers[i]; ++i)
174                 workQueue.append(currentFiber->m_fibers[i].get());
175             continue;
176         }
177
178         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
179         unsigned length = string->length();
180         position -= length;
181         StringImpl::copyChars(position, string->characters(), length);
182     }
183
184     ASSERT(buffer == position);
185     ASSERT(!isRope());
186 }
187
188 void JSString::outOfMemory(ExecState* exec) const
189 {
190     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
191         m_fibers[i].clear();
192     ASSERT(!isRope());
193     ASSERT(m_value == UString());
194     if (exec)
195         throwOutOfMemoryError(exec);
196 }
197
198 JSValue JSString::replaceCharacter(ExecState* exec, UChar character, const UString& replacement)
199 {
200     size_t matchPosition = value(exec).find(character);
201     if (matchPosition == notFound)
202         return JSValue(this);
203     return jsString(exec, m_value.substringSharingImpl(0, matchPosition), replacement, value(exec).substringSharingImpl(matchPosition + 1));
204 }
205
206 JSString* JSString::getIndexSlowCase(ExecState* exec, unsigned i)
207 {
208     ASSERT(isRope());
209     resolveRope(exec);
210     // Return a safe no-value result, this should never be used, since the excetion will be thrown.
211     if (exec->exception())
212         return jsString(exec, "");
213     ASSERT(!isRope());
214     ASSERT(i < m_value.length());
215     return jsSingleCharacterSubstring(exec, m_value, i);
216 }
217
218 JSValue JSString::toPrimitive(ExecState*, PreferredPrimitiveType) const
219 {
220     return const_cast<JSString*>(this);
221 }
222
223 bool JSString::getPrimitiveNumber(ExecState* exec, double& number, JSValue& result) const
224 {
225     result = this;
226     number = jsToNumber(value(exec));
227     return false;
228 }
229
230 bool JSString::toBoolean(ExecState*) const
231 {
232     return m_length;
233 }
234
235 double JSString::toNumber(ExecState* exec) const
236 {
237     return jsToNumber(value(exec));
238 }
239
240 UString JSString::toString(ExecState* exec) const
241 {
242     return value(exec);
243 }
244
245 inline StringObject* StringObject::create(ExecState* exec, JSGlobalObject* globalObject, JSString* string)
246 {
247     StringObject* object = new (allocateCell<StringObject>(*exec->heap())) StringObject(exec->globalData(), globalObject->stringObjectStructure());
248     object->finishCreation(exec->globalData(), string);
249     return object;
250 }
251
252 JSObject* JSString::toObject(ExecState* exec, JSGlobalObject* globalObject) const
253 {
254     return StringObject::create(exec, globalObject, const_cast<JSString*>(this));
255 }
256
257 JSObject* JSString::toThisObject(JSCell* cell, ExecState* exec)
258 {
259     return StringObject::create(exec, exec->lexicalGlobalObject(), jsCast<JSString*>(cell));
260 }
261
262 bool JSString::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
263 {
264     JSString* thisObject = jsCast<JSString*>(cell);
265     // The semantics here are really getPropertySlot, not getOwnPropertySlot.
266     // This function should only be called by JSValue::get.
267     if (thisObject->getStringPropertySlot(exec, propertyName, slot))
268         return true;
269     if (propertyName == exec->propertyNames().underscoreProto) {
270         slot.setValue(exec->lexicalGlobalObject()->stringPrototype());
271         return true;
272     }
273     slot.setBase(thisObject);
274     JSObject* object;
275     for (JSValue prototype = exec->lexicalGlobalObject()->stringPrototype(); !prototype.isNull(); prototype = object->prototype()) {
276         object = asObject(prototype);
277         if (object->methodTable()->getOwnPropertySlot(object, exec, propertyName, slot))
278             return true;
279     }
280     slot.setUndefined();
281     return true;
282 }
283
284 bool JSString::getStringPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
285 {
286     if (propertyName == exec->propertyNames().length) {
287         descriptor.setDescriptor(jsNumber(m_length), DontEnum | DontDelete | ReadOnly);
288         return true;
289     }
290     
291     bool isStrictUInt32;
292     unsigned i = propertyName.toUInt32(isStrictUInt32);
293     if (isStrictUInt32 && i < m_length) {
294         descriptor.setDescriptor(getIndex(exec, i), DontDelete | ReadOnly);
295         return true;
296     }
297     
298     return false;
299 }
300
301 bool JSString::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot)
302 {
303     JSString* thisObject = jsCast<JSString*>(cell);
304     // The semantics here are really getPropertySlot, not getOwnPropertySlot.
305     // This function should only be called by JSValue::get.
306     if (thisObject->getStringPropertySlot(exec, propertyName, slot))
307         return true;
308     return JSString::getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot);
309 }
310
311 } // namespace JSC