38de47adaeb8d4ee633ec88658e566b4082d71fb
[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 JSValuePtr stringProtoFuncToString(ExecState*, JSObject*, JSValuePtr, const ArgList&);
42 static JSValuePtr stringProtoFuncCharAt(ExecState*, JSObject*, JSValuePtr, const ArgList&);
43 static JSValuePtr stringProtoFuncCharCodeAt(ExecState*, JSObject*, JSValuePtr, const ArgList&);
44 static JSValuePtr stringProtoFuncConcat(ExecState*, JSObject*, JSValuePtr, const ArgList&);
45 static JSValuePtr stringProtoFuncIndexOf(ExecState*, JSObject*, JSValuePtr, const ArgList&);
46 static JSValuePtr stringProtoFuncLastIndexOf(ExecState*, JSObject*, JSValuePtr, const ArgList&);
47 static JSValuePtr stringProtoFuncMatch(ExecState*, JSObject*, JSValuePtr, const ArgList&);
48 static JSValuePtr stringProtoFuncReplace(ExecState*, JSObject*, JSValuePtr, const ArgList&);
49 static JSValuePtr stringProtoFuncSearch(ExecState*, JSObject*, JSValuePtr, const ArgList&);
50 static JSValuePtr stringProtoFuncSlice(ExecState*, JSObject*, JSValuePtr, const ArgList&);
51 static JSValuePtr stringProtoFuncSplit(ExecState*, JSObject*, JSValuePtr, const ArgList&);
52 static JSValuePtr stringProtoFuncSubstr(ExecState*, JSObject*, JSValuePtr, const ArgList&);
53 static JSValuePtr stringProtoFuncSubstring(ExecState*, JSObject*, JSValuePtr, const ArgList&);
54 static JSValuePtr stringProtoFuncToLowerCase(ExecState*, JSObject*, JSValuePtr, const ArgList&);
55 static JSValuePtr stringProtoFuncToUpperCase(ExecState*, JSObject*, JSValuePtr, const ArgList&);
56 static JSValuePtr stringProtoFuncLocaleCompare(ExecState*, JSObject*, JSValuePtr, const ArgList&);
57
58 static JSValuePtr stringProtoFuncBig(ExecState*, JSObject*, JSValuePtr, const ArgList&);
59 static JSValuePtr stringProtoFuncSmall(ExecState*, JSObject*, JSValuePtr, const ArgList&);
60 static JSValuePtr stringProtoFuncBlink(ExecState*, JSObject*, JSValuePtr, const ArgList&);
61 static JSValuePtr stringProtoFuncBold(ExecState*, JSObject*, JSValuePtr, const ArgList&);
62 static JSValuePtr stringProtoFuncFixed(ExecState*, JSObject*, JSValuePtr, const ArgList&);
63 static JSValuePtr stringProtoFuncItalics(ExecState*, JSObject*, JSValuePtr, const ArgList&);
64 static JSValuePtr stringProtoFuncStrike(ExecState*, JSObject*, JSValuePtr, const ArgList&);
65 static JSValuePtr stringProtoFuncSub(ExecState*, JSObject*, JSValuePtr, const ArgList&);
66 static JSValuePtr stringProtoFuncSup(ExecState*, JSObject*, JSValuePtr, const ArgList&);
67 static JSValuePtr stringProtoFuncFontcolor(ExecState*, JSObject*, JSValuePtr, const ArgList&);
68 static JSValuePtr stringProtoFuncFontsize(ExecState*, JSObject*, JSValuePtr, const ArgList&);
69 static JSValuePtr stringProtoFuncAnchor(ExecState*, JSObject*, JSValuePtr, const ArgList&);
70 static JSValuePtr stringProtoFuncLink(ExecState*, JSObject*, JSValuePtr, 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 JSValuePtr stringProtoFuncReplace(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
209 {
210     JSString* sourceVal = thisValue.toThisJSString(exec);
211     const UString& source = sourceVal->value();
212
213     JSValuePtr pattern = args.at(0);
214
215     JSValuePtr 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             while (true) {
241                 int matchIndex;
242                 int matchLen;
243                 int* ovector;
244                 regExpConstructor->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector);
245                 if (matchIndex < 0)
246                     break;
247                 
248                 sourceRanges.append(UString::Range(lastIndex, matchIndex - lastIndex));
249
250                 int completeMatchStart = ovector[0];
251                 unsigned i = 0;
252                 for (; i < reg->numSubpatterns() + 1; ++i) {
253                     int matchStart = ovector[i * 2];
254                     int matchLen = ovector[i * 2 + 1] - matchStart;
255
256                     if (matchStart < 0)
257                         cachedCall.setArgument(i, jsUndefined());
258                     else
259                         cachedCall.setArgument(i, jsSubstring(exec, source, matchStart, matchLen));
260                 }
261
262                 cachedCall.setArgument(i++, jsNumber(exec, completeMatchStart));
263                 cachedCall.setArgument(i++, sourceVal);
264                 
265                 cachedCall.setThis(exec->globalThisValue());
266                 replacements.append(cachedCall.call().toString(cachedCall.newCallFrame()));
267                 if (exec->hadException() || cachedCall.newCallFrame()->hadException())
268                     break;
269
270                 lastIndex = matchIndex + matchLen;
271                 startPosition = lastIndex;
272
273                 // special case of empty match
274                 if (matchLen == 0) {
275                     startPosition++;
276                     if (startPosition > source.size())
277                         break;
278                 }
279             }            
280         } else {
281             do {
282                 int matchIndex;
283                 int matchLen;
284                 int* ovector;
285                 regExpConstructor->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector);
286                 if (matchIndex < 0)
287                     break;
288
289                 sourceRanges.append(UString::Range(lastIndex, matchIndex - lastIndex));
290
291                 if (callType != CallTypeNone) {
292                     int completeMatchStart = ovector[0];
293                     MarkedArgumentBuffer args;
294
295                     for (unsigned i = 0; i < reg->numSubpatterns() + 1; ++i) {
296                         int matchStart = ovector[i * 2];
297                         int matchLen = ovector[i * 2 + 1] - matchStart;
298
299                         if (matchStart < 0)
300                             args.append(jsUndefined());
301                         else
302                             args.append(jsSubstring(exec, source, matchStart, matchLen));
303                     }
304
305                     args.append(jsNumber(exec, completeMatchStart));
306                     args.append(sourceVal);
307
308                     replacements.append(call(exec, replacement, callType, callData, exec->globalThisValue(), args).toString(exec));
309                     if (exec->hadException())
310                         break;
311                 } else
312                     replacements.append(substituteBackreferences(replacementString, source, ovector, reg));
313
314                 lastIndex = matchIndex + matchLen;
315                 startPosition = lastIndex;
316
317                 // special case of empty match
318                 if (matchLen == 0) {
319                     startPosition++;
320                     if (startPosition > source.size())
321                         break;
322                 }
323             } while (global);
324         }
325         if (lastIndex < source.size())
326             sourceRanges.append(UString::Range(lastIndex, source.size() - lastIndex));
327
328         UString result = source.spliceSubstringsWithSeparators(sourceRanges.data(), sourceRanges.size(), replacements.data(), replacements.size());
329
330         if (result == source)
331             return sourceVal;
332
333         return jsString(exec, result);
334     }
335
336     // First arg is a string
337     UString patternString = pattern.toString(exec);
338     int matchPos = source.find(patternString);
339     int matchLen = patternString.size();
340     // Do the replacement
341     if (matchPos == -1)
342         return sourceVal;
343
344     if (callType != CallTypeNone) {
345         MarkedArgumentBuffer args;
346         args.append(jsSubstring(exec, source, matchPos, matchLen));
347         args.append(jsNumber(exec, matchPos));
348         args.append(sourceVal);
349
350         replacementString = call(exec, replacement, callType, callData, exec->globalThisValue(), args).toString(exec);
351     }
352
353     int ovector[2] = { matchPos, matchPos + matchLen };
354     return jsString(exec, source.substr(0, matchPos)
355         + substituteBackreferences(replacementString, source, ovector, 0)
356         + source.substr(matchPos + matchLen));
357 }
358
359 JSValuePtr stringProtoFuncToString(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
360 {
361     // Also used for valueOf.
362
363     if (thisValue.isString())
364         return thisValue;
365
366     if (thisValue.isObject(&StringObject::info))
367         return asStringObject(thisValue)->internalValue();
368
369     return throwError(exec, TypeError);
370 }
371
372 JSValuePtr stringProtoFuncCharAt(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
373 {
374     UString s = thisValue.toThisString(exec);
375     unsigned len = s.size();
376     JSValuePtr a0 = args.at(0);
377     if (a0.isUInt32Fast()) {
378         uint32_t i = a0.getUInt32Fast();
379         if (i < len)
380             return jsSingleCharacterSubstring(exec, s, i);
381         return jsEmptyString(exec);
382     }
383     double dpos = a0.toInteger(exec);
384     if (dpos >= 0 && dpos < len)
385         return jsSingleCharacterSubstring(exec, s, static_cast<unsigned>(dpos));
386     return jsEmptyString(exec);
387 }
388
389 JSValuePtr stringProtoFuncCharCodeAt(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
390 {
391     UString s = thisValue.toThisString(exec);
392     unsigned len = s.size();
393     JSValuePtr a0 = args.at(0);
394     if (a0.isUInt32Fast()) {
395         uint32_t i = a0.getUInt32Fast();
396         if (i < len)
397             return jsNumber(exec, s.data()[i]);
398         return jsNaN(exec);
399     }
400     double dpos = a0.toInteger(exec);
401     if (dpos >= 0 && dpos < len)
402         return jsNumber(exec, s[static_cast<int>(dpos)]);
403     return jsNaN(exec);
404 }
405
406 JSValuePtr stringProtoFuncConcat(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
407 {
408     UString s = thisValue.toThisString(exec);
409
410     ArgList::const_iterator end = args.end();
411     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
412         s += (*it).toString(exec);
413     return jsString(exec, s);
414 }
415
416 JSValuePtr stringProtoFuncIndexOf(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
417 {
418     UString s = thisValue.toThisString(exec);
419     int len = s.size();
420
421     JSValuePtr a0 = args.at(0);
422     JSValuePtr a1 = args.at(1);
423     UString u2 = a0.toString(exec);
424     int pos;
425     if (a1.isUndefined())
426         pos = 0;
427     else if (a1.isUInt32Fast())
428         pos = min<uint32_t>(a1.getUInt32Fast(), len);
429     else {
430         double dpos = a1.toInteger(exec);
431         if (dpos < 0)
432             dpos = 0;
433         else if (dpos > len)
434             dpos = len;
435         pos = static_cast<int>(dpos);
436     }
437
438     return jsNumber(exec, s.find(u2, pos));
439 }
440
441 JSValuePtr stringProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
442 {
443     UString s = thisValue.toThisString(exec);
444     int len = s.size();
445
446     JSValuePtr a0 = args.at(0);
447     JSValuePtr a1 = args.at(1);
448
449     UString u2 = a0.toString(exec);
450     double dpos = a1.toIntegerPreserveNaN(exec);
451     if (dpos < 0)
452         dpos = 0;
453     else if (!(dpos <= len)) // true for NaN
454         dpos = len;
455     return jsNumber(exec, s.rfind(u2, static_cast<int>(dpos)));
456 }
457
458 JSValuePtr stringProtoFuncMatch(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
459 {
460     UString s = thisValue.toThisString(exec);
461
462     JSValuePtr a0 = args.at(0);
463
464     UString u = s;
465     RefPtr<RegExp> reg;
466     RegExpObject* imp = 0;
467     if (a0.isObject(&RegExpObject::info))
468         reg = asRegExpObject(a0)->regExp();
469     else {
470         /*
471          *  ECMA 15.5.4.12 String.prototype.search (regexp)
472          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
473          *  replaced with the result of the expression new RegExp(regexp).
474          */
475         reg = RegExp::create(&exec->globalData(), a0.toString(exec));
476     }
477     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
478     int pos;
479     int matchLength;
480     regExpConstructor->performMatch(reg.get(), u, 0, pos, matchLength);
481     if (!(reg->global())) {
482         // case without 'g' flag is handled like RegExp.prototype.exec
483         if (pos < 0)
484             return jsNull();
485         return regExpConstructor->arrayOfMatches(exec);
486     }
487
488     // return array of matches
489     MarkedArgumentBuffer list;
490     int lastIndex = 0;
491     while (pos >= 0) {
492         list.append(jsSubstring(exec, u, pos, matchLength));
493         lastIndex = pos;
494         pos += matchLength == 0 ? 1 : matchLength;
495         regExpConstructor->performMatch(reg.get(), u, pos, pos, matchLength);
496     }
497     if (imp)
498         imp->setLastIndex(lastIndex);
499     if (list.isEmpty()) {
500         // if there are no matches at all, it's important to return
501         // Null instead of an empty array, because this matches
502         // other browsers and because Null is a false value.
503         return jsNull();
504     }
505
506     return constructArray(exec, list);
507 }
508
509 JSValuePtr stringProtoFuncSearch(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
510 {
511     UString s = thisValue.toThisString(exec);
512
513     JSValuePtr a0 = args.at(0);
514
515     UString u = s;
516     RefPtr<RegExp> reg;
517     if (a0.isObject(&RegExpObject::info))
518         reg = asRegExpObject(a0)->regExp();
519     else { 
520         /*
521          *  ECMA 15.5.4.12 String.prototype.search (regexp)
522          *  If regexp is not an object whose [[Class]] property is "RegExp", it is
523          *  replaced with the result of the expression new RegExp(regexp).
524          */
525         reg = RegExp::create(&exec->globalData(), a0.toString(exec));
526     }
527     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
528     int pos;
529     int matchLength;
530     regExpConstructor->performMatch(reg.get(), u, 0, pos, matchLength);
531     return jsNumber(exec, pos);
532 }
533
534 JSValuePtr stringProtoFuncSlice(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
535 {
536     UString s = thisValue.toThisString(exec);
537     int len = s.size();
538
539     JSValuePtr a0 = args.at(0);
540     JSValuePtr a1 = args.at(1);
541
542     // The arg processing is very much like ArrayProtoFunc::Slice
543     double start = a0.toInteger(exec);
544     double end = a1.isUndefined() ? len : a1.toInteger(exec);
545     double from = start < 0 ? len + start : start;
546     double to = end < 0 ? len + end : end;
547     if (to > from && to > 0 && from < len) {
548         if (from < 0)
549             from = 0;
550         if (to > len)
551             to = len;
552         return jsSubstring(exec, s, static_cast<unsigned>(from), static_cast<unsigned>(to) - static_cast<unsigned>(from));
553     }
554
555     return jsEmptyString(exec);
556 }
557
558 JSValuePtr stringProtoFuncSplit(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
559 {
560     UString s = thisValue.toThisString(exec);
561
562     JSValuePtr a0 = args.at(0);
563     JSValuePtr a1 = args.at(1);
564
565     JSArray* result = constructEmptyArray(exec);
566     unsigned i = 0;
567     int p0 = 0;
568     unsigned limit = a1.isUndefined() ? 0xFFFFFFFFU : a1.toUInt32(exec);
569     if (a0.isObject(&RegExpObject::info)) {
570         RegExp* reg = asRegExpObject(a0)->regExp();
571         if (s.isEmpty() && reg->match(s, 0) >= 0) {
572             // empty string matched by regexp -> empty array
573             return result;
574         }
575         int pos = 0;
576         while (i != limit && pos < s.size()) {
577             OwnArrayPtr<int> ovector;
578             int mpos = reg->match(s, pos, &ovector);
579             if (mpos < 0)
580                 break;
581             int mlen = ovector[1] - ovector[0];
582             pos = mpos + (mlen == 0 ? 1 : mlen);
583             if (mpos != p0 || mlen) {
584                 result->put(exec, i++, jsSubstring(exec, s, p0, mpos - p0));
585                 p0 = mpos + mlen;
586             }
587             for (unsigned si = 1; si <= reg->numSubpatterns(); ++si) {
588                 int spos = ovector[si * 2];
589                 if (spos < 0)
590                     result->put(exec, i++, jsUndefined());
591                 else
592                     result->put(exec, i++, jsSubstring(exec, s, spos, ovector[si * 2 + 1] - spos));
593             }
594         }
595     } else {
596         UString u2 = a0.toString(exec);
597         if (u2.isEmpty()) {
598             if (s.isEmpty()) {
599                 // empty separator matches empty string -> empty array
600                 return result;
601             }
602             while (i != limit && p0 < s.size() - 1)
603                 result->put(exec, i++, jsSingleCharacterSubstring(exec, s, p0++));
604         } else {
605             int pos;
606             while (i != limit && (pos = s.find(u2, p0)) >= 0) {
607                 result->put(exec, i++, jsSubstring(exec, s, p0, pos - p0));
608                 p0 = pos + u2.size();
609             }
610         }
611     }
612
613     // add remaining string
614     if (i != limit)
615         result->put(exec, i++, jsSubstring(exec, s, p0, s.size() - p0));
616
617     return result;
618 }
619
620 JSValuePtr stringProtoFuncSubstr(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
621 {
622     UString s = thisValue.toThisString(exec);
623     int len = s.size();
624
625     JSValuePtr a0 = args.at(0);
626     JSValuePtr a1 = args.at(1);
627
628     double start = a0.toInteger(exec);
629     double length = a1.isUndefined() ? len : a1.toInteger(exec);
630     if (start >= len || length <= 0)
631         return jsEmptyString(exec);
632     if (start < 0) {
633         start += len;
634         if (start < 0)
635             start = 0;
636     }
637     if (start + length > len)
638         length = len - start;
639     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(length));
640 }
641
642 JSValuePtr stringProtoFuncSubstring(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
643 {
644     UString s = thisValue.toThisString(exec);
645     int len = s.size();
646
647     JSValuePtr a0 = args.at(0);
648     JSValuePtr a1 = args.at(1);
649
650     double start = a0.toNumber(exec);
651     double end = a1.toNumber(exec);
652     if (isnan(start))
653         start = 0;
654     if (isnan(end))
655         end = 0;
656     if (start < 0)
657         start = 0;
658     if (end < 0)
659         end = 0;
660     if (start > len)
661         start = len;
662     if (end > len)
663         end = len;
664     if (a1.isUndefined())
665         end = len;
666     if (start > end) {
667         double temp = end;
668         end = start;
669         start = temp;
670     }
671     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(end) - static_cast<unsigned>(start));
672 }
673
674 JSValuePtr stringProtoFuncToLowerCase(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
675 {
676     JSString* sVal = thisValue.toThisJSString(exec);
677     const UString& s = sVal->value();
678
679     int sSize = s.size();
680     if (!sSize)
681         return sVal;
682
683     const UChar* sData = s.data();
684     Vector<UChar> buffer(sSize);
685
686     UChar ored = 0;
687     for (int i = 0; i < sSize; i++) {
688         UChar c = sData[i];
689         ored |= c;
690         buffer[i] = toASCIILower(c);
691     }
692     if (!(ored & ~0x7f))
693         return jsString(exec, UString(buffer.releaseBuffer(), sSize, false));
694
695     bool error;
696     int length = Unicode::toLower(buffer.data(), sSize, sData, sSize, &error);
697     if (error) {
698         buffer.resize(length);
699         length = Unicode::toLower(buffer.data(), length, sData, sSize, &error);
700         if (error)
701             return sVal;
702     }
703     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
704         return sVal;
705     return jsString(exec, UString(buffer.releaseBuffer(), length, false));
706 }
707
708 JSValuePtr stringProtoFuncToUpperCase(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
709 {
710     JSString* sVal = thisValue.toThisJSString(exec);
711     const UString& s = sVal->value();
712
713     int sSize = s.size();
714     if (!sSize)
715         return sVal;
716
717     const UChar* sData = s.data();
718     Vector<UChar> buffer(sSize);
719
720     UChar ored = 0;
721     for (int i = 0; i < sSize; i++) {
722         UChar c = sData[i];
723         ored |= c;
724         buffer[i] = toASCIIUpper(c);
725     }
726     if (!(ored & ~0x7f))
727         return jsString(exec, UString(buffer.releaseBuffer(), sSize, false));
728
729     bool error;
730     int length = Unicode::toUpper(buffer.data(), sSize, sData, sSize, &error);
731     if (error) {
732         buffer.resize(length);
733         length = Unicode::toUpper(buffer.data(), length, sData, sSize, &error);
734         if (error)
735             return sVal;
736     }
737     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
738         return sVal;
739     return jsString(exec, UString(buffer.releaseBuffer(), length, false));
740 }
741
742 JSValuePtr stringProtoFuncLocaleCompare(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
743 {
744     if (args.size() < 1)
745       return jsNumber(exec, 0);
746
747     UString s = thisValue.toThisString(exec);
748     JSValuePtr a0 = args.at(0);
749     return jsNumber(exec, localeCompare(s, a0.toString(exec)));
750 }
751
752 JSValuePtr stringProtoFuncBig(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
753 {
754     UString s = thisValue.toThisString(exec);
755     return jsNontrivialString(exec, "<big>" + s + "</big>");
756 }
757
758 JSValuePtr stringProtoFuncSmall(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
759 {
760     UString s = thisValue.toThisString(exec);
761     return jsNontrivialString(exec, "<small>" + s + "</small>");
762 }
763
764 JSValuePtr stringProtoFuncBlink(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
765 {
766     UString s = thisValue.toThisString(exec);
767     return jsNontrivialString(exec, "<blink>" + s + "</blink>");
768 }
769
770 JSValuePtr stringProtoFuncBold(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
771 {
772     UString s = thisValue.toThisString(exec);
773     return jsNontrivialString(exec, "<b>" + s + "</b>");
774 }
775
776 JSValuePtr stringProtoFuncFixed(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
777 {
778     UString s = thisValue.toThisString(exec);
779     return jsString(exec, "<tt>" + s + "</tt>");
780 }
781
782 JSValuePtr stringProtoFuncItalics(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
783 {
784     UString s = thisValue.toThisString(exec);
785     return jsNontrivialString(exec, "<i>" + s + "</i>");
786 }
787
788 JSValuePtr stringProtoFuncStrike(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
789 {
790     UString s = thisValue.toThisString(exec);
791     return jsNontrivialString(exec, "<strike>" + s + "</strike>");
792 }
793
794 JSValuePtr stringProtoFuncSub(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
795 {
796     UString s = thisValue.toThisString(exec);
797     return jsNontrivialString(exec, "<sub>" + s + "</sub>");
798 }
799
800 JSValuePtr stringProtoFuncSup(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList&)
801 {
802     UString s = thisValue.toThisString(exec);
803     return jsNontrivialString(exec, "<sup>" + s + "</sup>");
804 }
805
806 JSValuePtr stringProtoFuncFontcolor(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
807 {
808     UString s = thisValue.toThisString(exec);
809     JSValuePtr a0 = args.at(0);
810     return jsNontrivialString(exec, "<font color=\"" + a0.toString(exec) + "\">" + s + "</font>");
811 }
812
813 JSValuePtr stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
814 {
815     UString s = thisValue.toThisString(exec);
816     JSValuePtr a0 = args.at(0);
817
818     uint32_t smallInteger;
819     if (a0.getUInt32(smallInteger) && smallInteger <= 9) {
820         unsigned stringSize = s.size();
821         unsigned bufferSize = 22 + stringSize;
822         UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
823         if (!buffer)
824             return jsUndefined();
825         buffer[0] = '<';
826         buffer[1] = 'f';
827         buffer[2] = 'o';
828         buffer[3] = 'n';
829         buffer[4] = 't';
830         buffer[5] = ' ';
831         buffer[6] = 's';
832         buffer[7] = 'i';
833         buffer[8] = 'z';
834         buffer[9] = 'e';
835         buffer[10] = '=';
836         buffer[11] = '"';
837         buffer[12] = '0' + smallInteger;
838         buffer[13] = '"';
839         buffer[14] = '>';
840         memcpy(&buffer[15], s.data(), stringSize * sizeof(UChar));
841         buffer[15 + stringSize] = '<';
842         buffer[16 + stringSize] = '/';
843         buffer[17 + stringSize] = 'f';
844         buffer[18 + stringSize] = 'o';
845         buffer[19 + stringSize] = 'n';
846         buffer[20 + stringSize] = 't';
847         buffer[21 + stringSize] = '>';
848         return jsNontrivialString(exec, UString(buffer, bufferSize, false));
849     }
850
851     return jsNontrivialString(exec, "<font size=\"" + a0.toString(exec) + "\">" + s + "</font>");
852 }
853
854 JSValuePtr stringProtoFuncAnchor(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
855 {
856     UString s = thisValue.toThisString(exec);
857     JSValuePtr a0 = args.at(0);
858     return jsNontrivialString(exec, "<a name=\"" + a0.toString(exec) + "\">" + s + "</a>");
859 }
860
861 JSValuePtr stringProtoFuncLink(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
862 {
863     UString s = thisValue.toThisString(exec);
864     JSValuePtr a0 = args.at(0);
865     UString linkText = a0.toString(exec);
866
867     unsigned linkTextSize = linkText.size();
868     unsigned stringSize = s.size();
869     unsigned bufferSize = 15 + linkTextSize + stringSize;
870     UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
871     if (!buffer)
872         return jsUndefined();
873     buffer[0] = '<';
874     buffer[1] = 'a';
875     buffer[2] = ' ';
876     buffer[3] = 'h';
877     buffer[4] = 'r';
878     buffer[5] = 'e';
879     buffer[6] = 'f';
880     buffer[7] = '=';
881     buffer[8] = '"';
882     memcpy(&buffer[9], linkText.data(), linkTextSize * sizeof(UChar));
883     buffer[9 + linkTextSize] = '"';
884     buffer[10 + linkTextSize] = '>';
885     memcpy(&buffer[11 + linkTextSize], s.data(), stringSize * sizeof(UChar));
886     buffer[11 + linkTextSize + stringSize] = '<';
887     buffer[12 + linkTextSize + stringSize] = '/';
888     buffer[13 + linkTextSize + stringSize] = 'a';
889     buffer[14 + linkTextSize + stringSize] = '>';
890     return jsNontrivialString(exec, UString(buffer, bufferSize, false));
891 }
892
893 } // namespace JSC