Investigate storing strings in 8-bit buffers when possible
[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 JSString::~JSString()
49 {
50     ASSERT(vptr() == JSGlobalData::jsStringVPtr);
51 }
52
53 void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
54 {
55     JSString* thisObject = static_cast<JSString*>(cell);
56     Base::visitChildren(thisObject, visitor);
57     for (size_t i = 0; i < s_maxInternalRopeLength && thisObject->m_fibers[i]; ++i)
58         visitor.append(&thisObject->m_fibers[i]);
59 }
60
61 void JSString::resolveRope(ExecState* exec) const
62 {
63     ASSERT(isRope());
64
65     UChar* buffer;
66     if (PassRefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer))
67         m_value = newImpl;
68     else {
69         outOfMemory(exec);
70         return;
71     }
72
73     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
74         if (m_fibers[i]->isRope())
75             return resolveRopeSlowCase(exec, buffer);
76     }
77
78     UChar* position = buffer;
79     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) {
80         StringImpl* string = m_fibers[i]->m_value.impl();
81         unsigned length = string->length();
82         StringImpl::copyChars(position, string->characters16(), length);
83         position += length;
84         m_fibers[i].clear();
85     }
86     ASSERT((buffer + m_length) == position);
87     ASSERT(!isRope());
88 }
89
90 // Overview: this methods converts a JSString from holding a string in rope form
91 // down to a simple UString representation.  It does so by building up the string
92 // backwards, since we want to avoid recursion, we expect that the tree structure
93 // representing the rope is likely imbalanced with more nodes down the left side
94 // (since appending to the string is likely more common) - and as such resolving
95 // in this fashion should minimize work queue size.  (If we built the queue forwards
96 // we would likely have to place all of the constituent StringImpls into the
97 // Vector before performing any concatenation, but by working backwards we likely
98 // only fill the queue with the number of substrings at any given level in a
99 // rope-of-ropes.)    
100 void JSString::resolveRopeSlowCase(ExecState* exec, UChar* buffer) const
101 {
102     UNUSED_PARAM(exec);
103
104     UChar* position = buffer + m_length; // We will be working backwards over the rope.
105     Vector<JSString*, 32> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
106     
107     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
108         workQueue.append(m_fibers[i].get());
109
110     while (!workQueue.isEmpty()) {
111         JSString* currentFiber = workQueue.last();
112         workQueue.removeLast();
113
114         if (currentFiber->isRope()) {
115             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiber->m_fibers[i]; ++i)
116                 workQueue.append(currentFiber->m_fibers[i].get());
117             continue;
118         }
119
120         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
121         unsigned length = string->length();
122         position -= length;
123         StringImpl::copyChars(position, string->characters16(), length);
124     }
125
126     ASSERT(buffer == position);
127     ASSERT(!isRope());
128 }
129
130 void JSString::outOfMemory(ExecState* exec) const
131 {
132     for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i)
133         m_fibers[i].clear();
134     ASSERT(!isRope());
135     ASSERT(m_value == UString());
136     if (exec)
137         throwOutOfMemoryError(exec);
138 }
139
140 JSValue JSString::replaceCharacter(ExecState* exec, UChar character, const UString& replacement)
141 {
142     size_t matchPosition = value(exec).find(character);
143     if (matchPosition == notFound)
144         return JSValue(this);
145     return jsString(exec, m_value.substringSharingImpl(0, matchPosition), replacement, value(exec).substringSharingImpl(matchPosition + 1));
146 }
147
148 JSString* JSString::getIndexSlowCase(ExecState* exec, unsigned i)
149 {
150     ASSERT(isRope());
151     resolveRope(exec);
152     // Return a safe no-value result, this should never be used, since the excetion will be thrown.
153     if (exec->exception())
154         return jsString(exec, "");
155     ASSERT(!isRope());
156     ASSERT(i < m_value.length());
157     return jsSingleCharacterSubstring(exec, m_value, i);
158 }
159
160 JSValue JSString::toPrimitive(ExecState*, PreferredPrimitiveType) const
161 {
162     return const_cast<JSString*>(this);
163 }
164
165 bool JSString::getPrimitiveNumber(ExecState* exec, double& number, JSValue& result) const
166 {
167     result = this;
168     number = jsToNumber(value(exec));
169     return false;
170 }
171
172 bool JSString::toBoolean(ExecState*) const
173 {
174     return m_length;
175 }
176
177 double JSString::toNumber(ExecState* exec) const
178 {
179     return jsToNumber(value(exec));
180 }
181
182 UString JSString::toString(ExecState* exec) const
183 {
184     return value(exec);
185 }
186
187 inline StringObject* StringObject::create(ExecState* exec, JSGlobalObject* globalObject, JSString* string)
188 {
189     StringObject* object = new (allocateCell<StringObject>(*exec->heap())) StringObject(exec->globalData(), globalObject->stringObjectStructure());
190     object->finishCreation(exec->globalData(), string);
191     return object;
192 }
193
194 JSObject* JSString::toObject(ExecState* exec, JSGlobalObject* globalObject) const
195 {
196     return StringObject::create(exec, globalObject, const_cast<JSString*>(this));
197 }
198
199 JSObject* JSString::toThisObject(JSCell* cell, ExecState* exec)
200 {
201     return StringObject::create(exec, exec->lexicalGlobalObject(), static_cast<JSString*>(cell));
202 }
203
204 bool JSString::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
205 {
206     JSString* thisObject = static_cast<JSString*>(cell);
207     // The semantics here are really getPropertySlot, not getOwnPropertySlot.
208     // This function should only be called by JSValue::get.
209     if (thisObject->getStringPropertySlot(exec, propertyName, slot))
210         return true;
211     if (propertyName == exec->propertyNames().underscoreProto) {
212         slot.setValue(exec->lexicalGlobalObject()->stringPrototype());
213         return true;
214     }
215     slot.setBase(thisObject);
216     JSObject* object;
217     for (JSValue prototype = exec->lexicalGlobalObject()->stringPrototype(); !prototype.isNull(); prototype = object->prototype()) {
218         object = asObject(prototype);
219         if (object->methodTable()->getOwnPropertySlot(object, exec, propertyName, slot))
220             return true;
221     }
222     slot.setUndefined();
223     return true;
224 }
225
226 bool JSString::getStringPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
227 {
228     if (propertyName == exec->propertyNames().length) {
229         descriptor.setDescriptor(jsNumber(m_length), DontEnum | DontDelete | ReadOnly);
230         return true;
231     }
232     
233     bool isStrictUInt32;
234     unsigned i = propertyName.toUInt32(isStrictUInt32);
235     if (isStrictUInt32 && i < m_length) {
236         descriptor.setDescriptor(getIndex(exec, i), DontDelete | ReadOnly);
237         return true;
238     }
239     
240     return false;
241 }
242
243 bool JSString::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
244 {
245     if (getStringPropertyDescriptor(exec, propertyName, descriptor))
246         return true;
247     if (propertyName != exec->propertyNames().underscoreProto)
248         return false;
249     descriptor.setDescriptor(exec->lexicalGlobalObject()->stringPrototype(), DontEnum);
250     return true;
251 }
252
253 bool JSString::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot)
254 {
255     JSString* thisObject = static_cast<JSString*>(cell);
256     // The semantics here are really getPropertySlot, not getOwnPropertySlot.
257     // This function should only be called by JSValue::get.
258     if (thisObject->getStringPropertySlot(exec, propertyName, slot))
259         return true;
260     return JSString::getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot);
261 }
262
263 } // namespace JSC