d6939cb5b41b45f3018a70fab03909ca2c9e294e
[WebKit.git] / JavaScriptCore / runtime / StringPrototype.cpp
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "StringPrototype.h"
23
24 #include "CachedCall.h"
25 #include "JSArray.h"
26 #include "JSFunction.h"
27 #include "ObjectPrototype.h"
28 #include "PropertyNameArray.h"
29 #include "RegExpConstructor.h"
30 #include "RegExpObject.h"
31 #include <wtf/ASCIICType.h>
32 #include <wtf/MathExtras.h>
33 #include <wtf/unicode/Collator.h>
34
35 using namespace WTF;
36
37 namespace JSC {
38
39 ASSERT_CLASS_FITS_IN_CELL(StringPrototype);
40
41 static JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
42 static JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState*, JSObject*, JSValue, const ArgList&);
43 static JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState*, JSObject*, JSValue, const ArgList&);
44 static JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState*, JSObject*, JSValue, const ArgList&);
45 static JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
46 static JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
47 static JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState*, JSObject*, JSValue, const ArgList&);
48 static JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState*, JSObject*, JSValue, const ArgList&);
49 static JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState*, JSObject*, JSValue, const ArgList&);
50 static JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState*, JSObject*, JSValue, const ArgList&);
51 static JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState*, JSObject*, JSValue, const ArgList&);
52 static JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState*, JSObject*, JSValue, const ArgList&);
53 static JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState*, JSObject*, JSValue, const ArgList&);
54 static JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState*, JSObject*, JSValue, const ArgList&);
55 static JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState*, JSObject*, JSValue, const ArgList&);
56 static JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState*, JSObject*, JSValue, const ArgList&);
57
58 static JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState*, JSObject*, JSValue, const ArgList&);
59 static JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState*, JSObject*, JSValue, const ArgList&);
60 static JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState*, JSObject*, JSValue, const ArgList&);
61 static JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState*, JSObject*, JSValue, const ArgList&);
62 static JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState*, JSObject*, JSValue, const ArgList&);
63 static JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState*, JSObject*, JSValue, const ArgList&);
64 static JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState*, JSObject*, JSValue, const ArgList&);
65 static JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState*, JSObject*, JSValue, const ArgList&);
66 static JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState*, JSObject*, JSValue, const ArgList&);
67 static JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState*, JSObject*, JSValue, const ArgList&);
68 static JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState*, JSObject*, JSValue, const ArgList&);
69 static JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState*, JSObject*, JSValue, const ArgList&);
70 static JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState*, JSObject*, JSValue, const ArgList&);
71
72 }
73
74 #include "StringPrototype.lut.h"
75
76 namespace JSC {
77
78 const ClassInfo StringPrototype::info = { "String", &StringObject::info, 0, ExecState::stringTable };
79
80 /* Source for StringPrototype.lut.h
81 @begin stringTable 26
82     toString              stringProtoFuncToString          DontEnum|Function       0
83     valueOf               stringProtoFuncToString          DontEnum|Function       0
84     charAt                stringProtoFuncCharAt            DontEnum|Function       1
85     charCodeAt            stringProtoFuncCharCodeAt        DontEnum|Function       1
86     concat                stringProtoFuncConcat            DontEnum|Function       1
87     indexOf               stringProtoFuncIndexOf           DontEnum|Function       1
88     lastIndexOf           stringProtoFuncLastIndexOf       DontEnum|Function       1
89     match                 stringProtoFuncMatch             DontEnum|Function       1
90     replace               stringProtoFuncReplace           DontEnum|Function       2
91     search                stringProtoFuncSearch            DontEnum|Function       1
92     slice                 stringProtoFuncSlice             DontEnum|Function       2
93     split                 stringProtoFuncSplit             DontEnum|Function       2
94     substr                stringProtoFuncSubstr            DontEnum|Function       2
95     substring             stringProtoFuncSubstring         DontEnum|Function       2
96     toLowerCase           stringProtoFuncToLowerCase       DontEnum|Function       0
97     toUpperCase           stringProtoFuncToUpperCase       DontEnum|Function       0
98     localeCompare         stringProtoFuncLocaleCompare     DontEnum|Function       1
99
100     # toLocaleLowerCase and toLocaleUpperCase are currently identical to toLowerCase and toUpperCase
101     toLocaleLowerCase     stringProtoFuncToLowerCase       DontEnum|Function       0
102     toLocaleUpperCase     stringProtoFuncToUpperCase       DontEnum|Function       0
103
104     big                   stringProtoFuncBig               DontEnum|Function       0
105     small                 stringProtoFuncSmall             DontEnum|Function       0
106     blink                 stringProtoFuncBlink             DontEnum|Function       0
107     bold                  stringProtoFuncBold              DontEnum|Function       0
108     fixed                 stringProtoFuncFixed             DontEnum|Function       0
109     italics               stringProtoFuncItalics           DontEnum|Function       0
110     strike                stringProtoFuncStrike            DontEnum|Function       0
111     sub                   stringProtoFuncSub               DontEnum|Function       0
112     sup                   stringProtoFuncSup               DontEnum|Function       0
113     fontcolor             stringProtoFuncFontcolor         DontEnum|Function       1
114     fontsize              stringProtoFuncFontsize          DontEnum|Function       1
115     anchor                stringProtoFuncAnchor            DontEnum|Function       1
116     link                  stringProtoFuncLink              DontEnum|Function       1
117 @end
118 */
119
120 // ECMA 15.5.4
121 StringPrototype::StringPrototype(ExecState* exec, PassRefPtr<Structure> structure)
122     : StringObject(exec, structure)
123 {
124     // The constructor will be added later, after StringConstructor has been built
125     putDirectWithoutTransition(exec->propertyNames().length, jsNumber(exec, 0), DontDelete | ReadOnly | DontEnum);
126 }
127
128 bool StringPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot &slot)
129 {
130     return getStaticFunctionSlot<StringObject>(exec, ExecState::stringTable(exec), this, propertyName, slot);
131 }
132
133 // ------------------------------ Functions --------------------------
134
135 static inline UString substituteBackreferences(const UString& replacement, const UString& source, const int* ovector, RegExp* reg)
136 {
137     UString substitutedReplacement;
138     int offset = 0;
139     int i = -1;
140     while ((i = replacement.find('$', i + 1)) != -1) {
141         if (i + 1 == replacement.size())
142             break;
143
144         UChar ref = replacement[i + 1];
145         if (ref == '$') {
146             // "$$" -> "$"
147             ++i;
148             substitutedReplacement.append(replacement.data() + offset, i - offset);
149             offset = i + 1;
150             continue;
151         }
152
153         int backrefStart;
154         int backrefLength;
155         int advance = 0;
156         if (ref == '&') {
157             backrefStart = ovector[0];
158             backrefLength = ovector[1] - backrefStart;
159         } else if (ref == '`') {
160             backrefStart = 0;
161             backrefLength = ovector[0];
162         } else if (ref == '\'') {
163             backrefStart = ovector[1];
164             backrefLength = source.size() - backrefStart;
165         } else if (reg && ref >= '0' && ref <= '9') {
166             // 1- and 2-digit back references are allowed
167             unsigned backrefIndex = ref - '0';
168             if (backrefIndex > reg->numSubpatterns())
169                 continue;
170             if (replacement.size() > i + 2) {
171                 ref = replacement[i + 2];
172                 if (ref >= '0' && ref <= '9') {
173                     backrefIndex = 10 * backrefIndex + ref - '0';
174                     if (backrefIndex > reg->numSubpatterns())
175                         backrefIndex = backrefIndex / 10;   // Fall back to the 1-digit reference
176                     else
177                         advance = 1;
178                 }
179             }
180             if (!backrefIndex)
181                 continue;
182             backrefStart = ovector[2 * backrefIndex];
183             backrefLength = ovector[2 * backrefIndex + 1] - backrefStart;
184         } else
185             continue;
186
187         if (i - offset)
188             substitutedReplacement.append(replacement.data() + offset, i - offset);
189         i += 1 + advance;
190         offset = i + 1;
191         substitutedReplacement.append(source.data() + backrefStart, backrefLength);
192     }
193
194     if (!offset)
195         return replacement;
196
197     if (replacement.size() - offset)
198         substitutedReplacement.append(replacement.data() + offset, replacement.size() - offset);
199
200     return substitutedReplacement;
201 }
202
203 static inline int localeCompare(const UString& a, const UString& b)
204 {
205     return Collator::userDefault()->collate(reinterpret_cast<const ::UChar*>(a.data()), a.size(), reinterpret_cast<const ::UChar*>(b.data()), b.size());
206 }
207
208 JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
209 {
210     JSString* sourceVal = thisValue.toThisJSString(exec);
211     const UString& source = sourceVal->value();
212
213     JSValue pattern = args.at(0);
214
215     JSValue replacement = args.at(1);
216     UString replacementString;
217     CallData callData;
218     CallType callType = replacement.getCallData(callData);
219     if (callType == CallTypeNone)
220         replacementString = replacement.toString(exec);
221
222     if (pattern.isObject(&RegExpObject::info)) {
223         RegExp* reg = asRegExpObject(pattern)->regExp();
224         bool global = reg->global();
225
226         RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
227
228         int lastIndex = 0;
229         int startPosition = 0;
230
231         Vector<UString::Range, 16> sourceRanges;
232         Vector<UString, 16> replacements;
233
234         // This is either a loop (if global is set) or a one-way (if not).
235         if (global && callType == CallTypeJS) {
236             // reg->numSubpatterns() + 1 for pattern args, + 2 for match start and sourceValue
237             int argCount = reg->numSubpatterns() + 1 + 2;
238             JSFunction* func = asFunction(replacement);
239             CachedCall cachedCall(exec, func, argCount, exec->exceptionSlot());
240             if (exec->hadException())
241                 return jsNull();
242             while (true) {
243                 int matchIndex;
244                 int matchLen;
245                 int* ovector;
246                 regExpConstructor->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector);
247                 if (matchIndex < 0)
248                     break;
249                 
250                 sourceRanges.append(UString::Range(lastIndex, matchIndex - lastIndex));
251
252                 int completeMatchStart = ovector[0];
253                 unsigned i = 0;
254                 for (; i < reg->numSubpatterns() + 1; ++i) {
255                     int matchStart = ovector[i * 2];
256                     int matchLen = ovector[i * 2 + 1] - matchStart;
257
258                     if (matchStart < 0)
259                         cachedCall.setArgument(i, jsUndefined());
260                     else
261                         cachedCall.setArgument(i, jsSubstring(exec, source, matchStart, matchLen));
262                 }
263
264                 cachedCall.setArgument(i++, jsNumber(exec, completeMatchStart));
265                 cachedCall.setArgument(i++, sourceVal);
266                 
267                 cachedCall.setThis(exec->globalThisValue());
268                 replacements.append(cachedCall.call().toString(cachedCall.newCallFrame()));
269                 if (exec->hadException())
270                     break;
271
272                 lastIndex = matchIndex + matchLen;
273                 startPosition = lastIndex;
274
275                 // special case of empty match
276                 if (matchLen == 0) {
277                     startPosition++;
278                     if (startPosition > source.size())
279                         break;
280                 }
281             }            
282         } else {
283             do {
284                 int matchIndex;
285                 int matchLen;
286                 int* ovector;
287                 regExpConstructor->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector);
288                 if (matchIndex < 0)
289                     break;
290
291                 sourceRanges.append(UString::Range(lastIndex, matchIndex - lastIndex));
292
293                 if (callType != CallTypeNone) {
294                     int completeMatchStart = ovector[0];
295                     MarkedArgumentBuffer args;
296
297                     for (unsigned i = 0; i < reg->numSubpatterns() + 1; ++i) {
298                         int matchStart = ovector[i * 2];
299                         int matchLen = ovector[i * 2 + 1] - matchStart;
300
301                         if (matchStart < 0)
302                             args.append(jsUndefined());
303                         else
304                             args.append(jsSubstring(exec, source, matchStart, matchLen));
305                     }
306
307                     args.append(jsNumber(exec, completeMatchStart));
308                     args.append(sourceVal);
309
310                     replacements.append(call(exec, replacement, callType, callData, exec->globalThisValue(), args).toString(exec));
311                     if (exec->hadException())
312                         break;
313                 } else
314                     replacements.append(substituteBackreferences(replacementString, source, ovector, reg));
315
316                 lastIndex = matchIndex + matchLen;
317                 startPosition = lastIndex;
318
319                 // special case of empty match
320                 if (matchLen == 0) {
321                     startPosition++;
322                     if (startPosition > source.size())
323                         break;
324                 }
325             } while (global);
326         }
327
328         if (!lastIndex && replacements.isEmpty())
329             return sourceVal;
330
331         if (lastIndex < source.size())
332             sourceRanges.append(UString::Range(lastIndex, source.size() - lastIndex));
333
334         return jsString(exec, source.spliceSubstringsWithSeparators(sourceRanges.data(), sourceRanges.size(),
335             replacements.data(), replacements.size()));
336     }
337
338     // Not a regular expression, so treat the pattern as a string.
339
340     UString patternString = pattern.toString(exec);
341     int matchPos = source.find(patternString);
342
343     if (matchPos == -1)
344         return sourceVal;
345
346     int matchLen = patternString.size();
347     if (callType != CallTypeNone) {
348         MarkedArgumentBuffer args;
349         args.append(jsSubstring(exec, source, matchPos, matchLen));
350         args.append(jsNumber(exec, matchPos));
351         args.append(sourceVal);
352
353         replacementString = call(exec, replacement, callType, callData, exec->globalThisValue(), args).toString(exec);
354     }
355
356     int ovector[2] = { matchPos, matchPos + matchLen };
357     return jsString(exec, source.replaceRange(matchPos, matchLen, substituteBackreferences(replacementString, source, ovector, 0)));
358 }
359
360 JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
361 {
362     // Also used for valueOf.
363
364     if (thisValue.isString())
365         return thisValue;
366
367     if (thisValue.isObject(&StringObject::info))
368         return asStringObject(thisValue)->internalValue();
369
370     return throwError(exec, TypeError);
371 }
372
373 JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
374 {
375     UString s = thisValue.toThisString(exec);
376     unsigned len = s.size();
377     JSValue a0 = args.at(0);
378     if (a0.isUInt32Fast()) {
379         uint32_t i = a0.getUInt32Fast();
380         if (i < len)
381             return jsSingleCharacterSubstring(exec, s, i);
382         return jsEmptyString(exec);
383     }
384     double dpos = a0.toInteger(exec);
385     if (dpos >= 0 && dpos < len)
386         return jsSingleCharacterSubstring(exec, s, static_cast<unsigned>(dpos));
387     return jsEmptyString(exec);
388 }
389
390 JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
391 {
392     UString s = thisValue.toThisString(exec);
393     unsigned len = s.size();
394     JSValue a0 = args.at(0);
395     if (a0.isUInt32Fast()) {
396         uint32_t i = a0.getUInt32Fast();
397         if (i < len)
398             return jsNumber(exec, s.data()[i]);
399         return jsNaN(exec);
400     }
401     double dpos = a0.toInteger(exec);
402     if (dpos >= 0 && dpos < len)
403         return jsNumber(exec, s[static_cast<int>(dpos)]);
404     return jsNaN(exec);
405 }
406
407 JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
408 {
409     UString s = thisValue.toThisString(exec);
410
411     ArgList::const_iterator end = args.end();
412     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
413         s += (*it).toString(exec);
414     return jsString(exec, s);
415 }
416
417 JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
418 {
419     UString s = thisValue.toThisString(exec);
420     int len = s.size();
421
422     JSValue a0 = args.at(0);
423     JSValue a1 = args.at(1);
424     UString u2 = a0.toString(exec);
425     int pos;
426     if (a1.isUndefined())
427         pos = 0;
428     else if (a1.isUInt32Fast())
429         pos = min<uint32_t>(a1.getUInt32Fast(), len);
430     else {
431         double dpos = a1.toInteger(exec);
432         if (dpos < 0)
433             dpos = 0;
434         else if (dpos > len)
435             dpos = len;
436         pos = static_cast<int>(dpos);
437     }
438
439     return jsNumber(exec, s.find(u2, pos));
440 }
441
442 JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
443 {
444     UString s = thisValue.toThisString(exec);
445     int len = s.size();
446
447     JSValue a0 = args.at(0);
448     JSValue a1 = args.at(1);
449
450     UString u2 = a0.toString(exec);
451     double dpos = a1.toIntegerPreserveNaN(exec);
452     if (dpos < 0)
453         dpos = 0;
454     else if (!(dpos <= len)) // true for NaN
455         dpos = len;
456     return jsNumber(exec, s.rfind(u2, static_cast<int>(dpos)));
457 }
458
459 JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
460 {
461     UString s = thisValue.toThisString(exec);
462
463     JSValue a0 = args.at(0);
464
465     UString u = s;
466     RefPtr<RegExp> reg;
467     RegExpObject* imp = 0;
468     if (a0.isObject(&RegExpObject::info))
469         reg = asRegExpObject(a0)->regExp();
470     else {
471         /*
472          *  ECMA 15.5.4.12 String.prototype.search (regexp)
473          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
474          *  replaced with the result of the expression new RegExp(regexp).
475          */
476         reg = RegExp::create(&exec->globalData(), a0.toString(exec));
477     }
478     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
479     int pos;
480     int matchLength;
481     regExpConstructor->performMatch(reg.get(), u, 0, pos, matchLength);
482     if (!(reg->global())) {
483         // case without 'g' flag is handled like RegExp.prototype.exec
484         if (pos < 0)
485             return jsNull();
486         return regExpConstructor->arrayOfMatches(exec);
487     }
488
489     // return array of matches
490     MarkedArgumentBuffer list;
491     int lastIndex = 0;
492     while (pos >= 0) {
493         list.append(jsSubstring(exec, u, pos, matchLength));
494         lastIndex = pos;
495         pos += matchLength == 0 ? 1 : matchLength;
496         regExpConstructor->performMatch(reg.get(), u, pos, pos, matchLength);
497     }
498     if (imp)
499         imp->setLastIndex(lastIndex);
500     if (list.isEmpty()) {
501         // if there are no matches at all, it's important to return
502         // Null instead of an empty array, because this matches
503         // other browsers and because Null is a false value.
504         return jsNull();
505     }
506
507     return constructArray(exec, list);
508 }
509
510 JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
511 {
512     UString s = thisValue.toThisString(exec);
513
514     JSValue a0 = args.at(0);
515
516     UString u = s;
517     RefPtr<RegExp> reg;
518     if (a0.isObject(&RegExpObject::info))
519         reg = asRegExpObject(a0)->regExp();
520     else { 
521         /*
522          *  ECMA 15.5.4.12 String.prototype.search (regexp)
523          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
524          *  replaced with the result of the expression new RegExp(regexp).
525          */
526         reg = RegExp::create(&exec->globalData(), a0.toString(exec));
527     }
528     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
529     int pos;
530     int matchLength;
531     regExpConstructor->performMatch(reg.get(), u, 0, pos, matchLength);
532     return jsNumber(exec, pos);
533 }
534
535 JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
536 {
537     UString s = thisValue.toThisString(exec);
538     int len = s.size();
539
540     JSValue a0 = args.at(0);
541     JSValue a1 = args.at(1);
542
543     // The arg processing is very much like ArrayProtoFunc::Slice
544     double start = a0.toInteger(exec);
545     double end = a1.isUndefined() ? len : a1.toInteger(exec);
546     double from = start < 0 ? len + start : start;
547     double to = end < 0 ? len + end : end;
548     if (to > from && to > 0 && from < len) {
549         if (from < 0)
550             from = 0;
551         if (to > len)
552             to = len;
553         return jsSubstring(exec, s, static_cast<unsigned>(from), static_cast<unsigned>(to) - static_cast<unsigned>(from));
554     }
555
556     return jsEmptyString(exec);
557 }
558
559 JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
560 {
561     UString s = thisValue.toThisString(exec);
562
563     JSValue a0 = args.at(0);
564     JSValue a1 = args.at(1);
565
566     JSArray* result = constructEmptyArray(exec);
567     unsigned i = 0;
568     int p0 = 0;
569     unsigned limit = a1.isUndefined() ? 0xFFFFFFFFU : a1.toUInt32(exec);
570     if (a0.isObject(&RegExpObject::info)) {
571         RegExp* reg = asRegExpObject(a0)->regExp();
572         if (s.isEmpty() && reg->match(s, 0) >= 0) {
573             // empty string matched by regexp -> empty array
574             return result;
575         }
576         int pos = 0;
577         while (i != limit && pos < s.size()) {
578             OwnArrayPtr<int> ovector;
579             int mpos = reg->match(s, pos, &ovector);
580             if (mpos < 0)
581                 break;
582             int mlen = ovector[1] - ovector[0];
583             pos = mpos + (mlen == 0 ? 1 : mlen);
584             if (mpos != p0 || mlen) {
585                 result->put(exec, i++, jsSubstring(exec, s, p0, mpos - p0));
586                 p0 = mpos + mlen;
587             }
588             for (unsigned si = 1; si <= reg->numSubpatterns(); ++si) {
589                 int spos = ovector[si * 2];
590                 if (spos < 0)
591                     result->put(exec, i++, jsUndefined());
592                 else
593                     result->put(exec, i++, jsSubstring(exec, s, spos, ovector[si * 2 + 1] - spos));
594             }
595         }
596     } else {
597         UString u2 = a0.toString(exec);
598         if (u2.isEmpty()) {
599             if (s.isEmpty()) {
600                 // empty separator matches empty string -> empty array
601                 return result;
602             }
603             while (i != limit && p0 < s.size() - 1)
604                 result->put(exec, i++, jsSingleCharacterSubstring(exec, s, p0++));
605         } else {
606             int pos;
607             while (i != limit && (pos = s.find(u2, p0)) >= 0) {
608                 result->put(exec, i++, jsSubstring(exec, s, p0, pos - p0));
609                 p0 = pos + u2.size();
610             }
611         }
612     }
613
614     // add remaining string
615     if (i != limit)
616         result->put(exec, i++, jsSubstring(exec, s, p0, s.size() - p0));
617
618     return result;
619 }
620
621 JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
622 {
623     UString s = thisValue.toThisString(exec);
624     int len = s.size();
625
626     JSValue a0 = args.at(0);
627     JSValue a1 = args.at(1);
628
629     double start = a0.toInteger(exec);
630     double length = a1.isUndefined() ? len : a1.toInteger(exec);
631     if (start >= len || length <= 0)
632         return jsEmptyString(exec);
633     if (start < 0) {
634         start += len;
635         if (start < 0)
636             start = 0;
637     }
638     if (start + length > len)
639         length = len - start;
640     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(length));
641 }
642
643 JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
644 {
645     UString s = thisValue.toThisString(exec);
646     int len = s.size();
647
648     JSValue a0 = args.at(0);
649     JSValue a1 = args.at(1);
650
651     double start = a0.toNumber(exec);
652     double end = a1.toNumber(exec);
653     if (isnan(start))
654         start = 0;
655     if (isnan(end))
656         end = 0;
657     if (start < 0)
658         start = 0;
659     if (end < 0)
660         end = 0;
661     if (start > len)
662         start = len;
663     if (end > len)
664         end = len;
665     if (a1.isUndefined())
666         end = len;
667     if (start > end) {
668         double temp = end;
669         end = start;
670         start = temp;
671     }
672     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(end) - static_cast<unsigned>(start));
673 }
674
675 JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
676 {
677     JSString* sVal = thisValue.toThisJSString(exec);
678     const UString& s = sVal->value();
679
680     int sSize = s.size();
681     if (!sSize)
682         return sVal;
683
684     const UChar* sData = s.data();
685     Vector<UChar> buffer(sSize);
686
687     UChar ored = 0;
688     for (int i = 0; i < sSize; i++) {
689         UChar c = sData[i];
690         ored |= c;
691         buffer[i] = toASCIILower(c);
692     }
693     if (!(ored & ~0x7f))
694         return jsString(exec, UString(buffer.releaseBuffer(), sSize, false));
695
696     bool error;
697     int length = Unicode::toLower(buffer.data(), sSize, sData, sSize, &error);
698     if (error) {
699         buffer.resize(length);
700         length = Unicode::toLower(buffer.data(), length, sData, sSize, &error);
701         if (error)
702             return sVal;
703     }
704     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
705         return sVal;
706     return jsString(exec, UString(buffer.releaseBuffer(), length, false));
707 }
708
709 JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
710 {
711     JSString* sVal = thisValue.toThisJSString(exec);
712     const UString& s = sVal->value();
713
714     int sSize = s.size();
715     if (!sSize)
716         return sVal;
717
718     const UChar* sData = s.data();
719     Vector<UChar> buffer(sSize);
720
721     UChar ored = 0;
722     for (int i = 0; i < sSize; i++) {
723         UChar c = sData[i];
724         ored |= c;
725         buffer[i] = toASCIIUpper(c);
726     }
727     if (!(ored & ~0x7f))
728         return jsString(exec, UString(buffer.releaseBuffer(), sSize, false));
729
730     bool error;
731     int length = Unicode::toUpper(buffer.data(), sSize, sData, sSize, &error);
732     if (error) {
733         buffer.resize(length);
734         length = Unicode::toUpper(buffer.data(), length, sData, sSize, &error);
735         if (error)
736             return sVal;
737     }
738     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
739         return sVal;
740     return jsString(exec, UString(buffer.releaseBuffer(), length, false));
741 }
742
743 JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
744 {
745     if (args.size() < 1)
746       return jsNumber(exec, 0);
747
748     UString s = thisValue.toThisString(exec);
749     JSValue a0 = args.at(0);
750     return jsNumber(exec, localeCompare(s, a0.toString(exec)));
751 }
752
753 JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
754 {
755     UString s = thisValue.toThisString(exec);
756     return jsNontrivialString(exec, "<big>" + s + "</big>");
757 }
758
759 JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
760 {
761     UString s = thisValue.toThisString(exec);
762     return jsNontrivialString(exec, "<small>" + s + "</small>");
763 }
764
765 JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
766 {
767     UString s = thisValue.toThisString(exec);
768     return jsNontrivialString(exec, "<blink>" + s + "</blink>");
769 }
770
771 JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
772 {
773     UString s = thisValue.toThisString(exec);
774     return jsNontrivialString(exec, "<b>" + s + "</b>");
775 }
776
777 JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
778 {
779     UString s = thisValue.toThisString(exec);
780     return jsString(exec, "<tt>" + s + "</tt>");
781 }
782
783 JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
784 {
785     UString s = thisValue.toThisString(exec);
786     return jsNontrivialString(exec, "<i>" + s + "</i>");
787 }
788
789 JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
790 {
791     UString s = thisValue.toThisString(exec);
792     return jsNontrivialString(exec, "<strike>" + s + "</strike>");
793 }
794
795 JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
796 {
797     UString s = thisValue.toThisString(exec);
798     return jsNontrivialString(exec, "<sub>" + s + "</sub>");
799 }
800
801 JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
802 {
803     UString s = thisValue.toThisString(exec);
804     return jsNontrivialString(exec, "<sup>" + s + "</sup>");
805 }
806
807 JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
808 {
809     UString s = thisValue.toThisString(exec);
810     JSValue a0 = args.at(0);
811     return jsNontrivialString(exec, "<font color=\"" + a0.toString(exec) + "\">" + s + "</font>");
812 }
813
814 JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
815 {
816     UString s = thisValue.toThisString(exec);
817     JSValue a0 = args.at(0);
818
819     uint32_t smallInteger;
820     if (a0.getUInt32(smallInteger) && smallInteger <= 9) {
821         unsigned stringSize = s.size();
822         unsigned bufferSize = 22 + stringSize;
823         UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
824         if (!buffer)
825             return jsUndefined();
826         buffer[0] = '<';
827         buffer[1] = 'f';
828         buffer[2] = 'o';
829         buffer[3] = 'n';
830         buffer[4] = 't';
831         buffer[5] = ' ';
832         buffer[6] = 's';
833         buffer[7] = 'i';
834         buffer[8] = 'z';
835         buffer[9] = 'e';
836         buffer[10] = '=';
837         buffer[11] = '"';
838         buffer[12] = '0' + smallInteger;
839         buffer[13] = '"';
840         buffer[14] = '>';
841         memcpy(&buffer[15], s.data(), stringSize * sizeof(UChar));
842         buffer[15 + stringSize] = '<';
843         buffer[16 + stringSize] = '/';
844         buffer[17 + stringSize] = 'f';
845         buffer[18 + stringSize] = 'o';
846         buffer[19 + stringSize] = 'n';
847         buffer[20 + stringSize] = 't';
848         buffer[21 + stringSize] = '>';
849         return jsNontrivialString(exec, UString(buffer, bufferSize, false));
850     }
851
852     return jsNontrivialString(exec, "<font size=\"" + a0.toString(exec) + "\">" + s + "</font>");
853 }
854
855 JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
856 {
857     UString s = thisValue.toThisString(exec);
858     JSValue a0 = args.at(0);
859     return jsNontrivialString(exec, "<a name=\"" + a0.toString(exec) + "\">" + s + "</a>");
860 }
861
862 JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
863 {
864     UString s = thisValue.toThisString(exec);
865     JSValue a0 = args.at(0);
866     UString linkText = a0.toString(exec);
867
868     unsigned linkTextSize = linkText.size();
869     unsigned stringSize = s.size();
870     unsigned bufferSize = 15 + linkTextSize + stringSize;
871     UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
872     if (!buffer)
873         return jsUndefined();
874     buffer[0] = '<';
875     buffer[1] = 'a';
876     buffer[2] = ' ';
877     buffer[3] = 'h';
878     buffer[4] = 'r';
879     buffer[5] = 'e';
880     buffer[6] = 'f';
881     buffer[7] = '=';
882     buffer[8] = '"';
883     memcpy(&buffer[9], linkText.data(), linkTextSize * sizeof(UChar));
884     buffer[9 + linkTextSize] = '"';
885     buffer[10 + linkTextSize] = '>';
886     memcpy(&buffer[11 + linkTextSize], s.data(), stringSize * sizeof(UChar));
887     buffer[11 + linkTextSize + stringSize] = '<';
888     buffer[12 + linkTextSize + stringSize] = '/';
889     buffer[13 + linkTextSize + stringSize] = 'a';
890     buffer[14 + linkTextSize + stringSize] = '>';
891     return jsNontrivialString(exec, UString(buffer, bufferSize, false));
892 }
893
894 } // namespace JSC