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