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