JavaScriptCore/runtime/StringPrototype.cpp

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