Roll out recent threading changes (r32807, r32810, r32819, r32822) to simplify
[WebKit-https.git] / JavaScriptCore / kjs / string_object.cpp
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
4  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
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 "string_object.h"
24 #include "string_object.lut.h"
25
26 #include "JSWrapperObject.h"
27 #include "PropertyNameArray.h"
28 #include "array_object.h"
29 #include "error_object.h"
30 #include "operations.h"
31 #include "regexp_object.h"
32 #include <wtf/MathExtras.h>
33 #include <wtf/unicode/Collator.h>
34
35 using namespace WTF;
36
37 namespace KJS {
38
39 // ------------------------------ StringInstance ----------------------------
40
41 const ClassInfo StringInstance::info = { "String", 0, 0, 0 };
42
43 StringInstance::StringInstance(JSObject *proto)
44   : JSWrapperObject(proto)
45 {
46   setInternalValue(jsString(""));
47 }
48
49 StringInstance::StringInstance(JSObject *proto, StringImp* string)
50   : JSWrapperObject(proto)
51 {
52   setInternalValue(string);
53 }
54
55 StringInstance::StringInstance(JSObject *proto, const UString &string)
56   : JSWrapperObject(proto)
57 {
58   setInternalValue(jsString(string));
59 }
60
61 JSValue *StringInstance::lengthGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot &slot)
62 {
63     return jsNumber(static_cast<StringInstance*>(slot.slotBase())->internalValue()->value().size());
64 }
65
66 JSValue* StringInstance::indexGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)
67 {
68     return jsString(static_cast<StringInstance*>(slot.slotBase())->internalValue()->value().substr(slot.index(), 1));
69 }
70
71 static JSValue* stringInstanceNumericPropertyGetter(ExecState*, JSObject*, unsigned index, const PropertySlot& slot)
72 {
73     return jsString(static_cast<StringInstance*>(slot.slotBase())->internalValue()->value().substr(index, 1));
74 }
75
76 bool StringInstance::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
77 {
78     if (propertyName == exec->propertyNames().length) {
79         slot.setCustom(this, lengthGetter);
80         return true;
81     }
82
83     bool isStrictUInt32;
84     unsigned i = propertyName.toStrictUInt32(&isStrictUInt32);
85     unsigned length = internalValue()->value().size();
86     if (isStrictUInt32 && i < length) {
87         slot.setCustomIndex(this, i, indexGetter);
88         return true;
89     }
90     
91     return JSObject::getOwnPropertySlot(exec, propertyName, slot);
92 }
93     
94 bool StringInstance::getOwnPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)
95 {
96     unsigned length = internalValue()->value().size();
97     if (propertyName < length) {
98         slot.setCustomNumeric(this, stringInstanceNumericPropertyGetter);
99         return true;
100     }
101     
102     return JSObject::getOwnPropertySlot(exec, Identifier::from(propertyName), slot);
103 }
104
105 void StringInstance::put(ExecState* exec, const Identifier& propertyName, JSValue* value)
106 {
107     if (propertyName == exec->propertyNames().length)
108         return;
109     JSObject::put(exec, propertyName, value);
110 }
111
112 bool StringInstance::deleteProperty(ExecState *exec, const Identifier &propertyName)
113 {
114   if (propertyName == exec->propertyNames().length)
115     return false;
116   return JSObject::deleteProperty(exec, propertyName);
117 }
118
119 void StringInstance::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
120 {
121   int size = internalValue()->getString().size();
122   for (int i = 0; i < size; i++)
123     propertyNames.add(Identifier(UString::from(i)));
124   return JSObject::getPropertyNames(exec, propertyNames);
125 }
126
127 // ------------------------------ StringPrototype ---------------------------
128 const ClassInfo StringPrototype::info = { "String", &StringInstance::info, 0, ExecState::stringTable };
129 /* Source for string_object.lut.h
130 @begin stringTable 26
131   toString              &stringProtoFuncToString          DontEnum|Function       0
132   valueOf               &stringProtoFuncValueOf           DontEnum|Function       0
133   charAt                &stringProtoFuncCharAt            DontEnum|Function       1
134   charCodeAt            &stringProtoFuncCharCodeAt        DontEnum|Function       1
135   concat                &stringProtoFuncConcat            DontEnum|Function       1
136   indexOf               &stringProtoFuncIndexOf           DontEnum|Function       1
137   lastIndexOf           &stringProtoFuncLastIndexOf       DontEnum|Function       1
138   match                 &stringProtoFuncMatch             DontEnum|Function       1
139   replace               &stringProtoFuncReplace           DontEnum|Function       2
140   search                &stringProtoFuncSearch            DontEnum|Function       1
141   slice                 &stringProtoFuncSlice             DontEnum|Function       2
142   split                 &stringProtoFuncSplit             DontEnum|Function       2
143   substr                &stringProtoFuncSubstr            DontEnum|Function       2
144   substring             &stringProtoFuncSubstring         DontEnum|Function       2
145   toLowerCase           &stringProtoFuncToLowerCase       DontEnum|Function       0
146   toUpperCase           &stringProtoFuncToUpperCase       DontEnum|Function       0
147   toLocaleLowerCase     &stringProtoFuncToLocaleLowerCase DontEnum|Function       0
148   toLocaleUpperCase     &stringProtoFuncToLocaleUpperCase DontEnum|Function       0
149   localeCompare         &stringProtoFuncLocaleCompare     DontEnum|Function       1
150
151   big                   &stringProtoFuncBig               DontEnum|Function       0
152   small                 &stringProtoFuncSmall             DontEnum|Function       0
153   blink                 &stringProtoFuncBlink             DontEnum|Function       0
154   bold                  &stringProtoFuncBold              DontEnum|Function       0
155   fixed                 &stringProtoFuncFixed             DontEnum|Function       0
156   italics               &stringProtoFuncItalics           DontEnum|Function       0
157   strike                &stringProtoFuncStrike            DontEnum|Function       0
158   sub                   &stringProtoFuncSub               DontEnum|Function       0
159   sup                   &stringProtoFuncSup               DontEnum|Function       0
160   fontcolor             &stringProtoFuncFontcolor         DontEnum|Function       1
161   fontsize              &stringProtoFuncFontsize          DontEnum|Function       1
162   anchor                &stringProtoFuncAnchor            DontEnum|Function       1
163   link                  &stringProtoFuncLink              DontEnum|Function       1
164 @end
165 */
166 // ECMA 15.5.4
167 StringPrototype::StringPrototype(ExecState* exec, ObjectPrototype* objProto)
168   : StringInstance(objProto)
169 {
170   // The constructor will be added later, after StringObjectImp has been built
171   putDirect(exec->propertyNames().length, jsNumber(0), DontDelete | ReadOnly | DontEnum);
172 }
173
174 bool StringPrototype::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot &slot)
175 {
176   return getStaticFunctionSlot<StringInstance>(exec, ExecState::stringTable(exec), this, propertyName, slot);
177 }
178
179 // ------------------------------ Functions --------------------------
180
181 static inline void expandSourceRanges(UString::Range * & array, int& count, int& capacity)
182 {
183   int newCapacity;
184   if (capacity == 0) {
185     newCapacity = 16;
186   } else {
187     newCapacity = capacity * 2;
188   }
189
190   UString::Range *newArray = new UString::Range[newCapacity];
191   for (int i = 0; i < count; i++) {
192     newArray[i] = array[i];
193   }
194
195   delete [] array;
196
197   capacity = newCapacity;
198   array = newArray;
199 }
200
201 static void pushSourceRange(UString::Range * & array, int& count, int& capacity, UString::Range range)
202 {
203   if (count + 1 > capacity)
204     expandSourceRanges(array, count, capacity);
205
206   array[count] = range;
207   count++;
208 }
209
210 static inline void expandReplacements(UString * & array, int& count, int& capacity)
211 {
212   int newCapacity;
213   if (capacity == 0) {
214     newCapacity = 16;
215   } else {
216     newCapacity = capacity * 2;
217   }
218
219   UString *newArray = new UString[newCapacity];
220   for (int i = 0; i < count; i++) {
221     newArray[i] = array[i];
222   }
223   
224   delete [] array;
225
226   capacity = newCapacity;
227   array = newArray;
228 }
229
230 static void pushReplacement(UString * & array, int& count, int& capacity, UString replacement)
231 {
232   if (count + 1 > capacity)
233     expandReplacements(array, count, capacity);
234
235   array[count] = replacement;
236   count++;
237 }
238
239 static inline UString substituteBackreferences(const UString &replacement, const UString &source, int *ovector, RegExp *reg)
240 {
241   UString substitutedReplacement = replacement;
242
243   int i = -1;
244   while ((i = substitutedReplacement.find(UString("$"), i + 1)) != -1) {
245     if (i+1 == substitutedReplacement.size())
246         break;
247
248     unsigned short ref = substitutedReplacement[i+1];
249     int backrefStart = 0;
250     int backrefLength = 0;
251     int advance = 0;
252
253     if (ref == '$') {  // "$$" -> "$"
254         substitutedReplacement = substitutedReplacement.substr(0, i + 1) + substitutedReplacement.substr(i + 2);
255         continue;
256     } else if (ref == '&') {
257         backrefStart = ovector[0];
258         backrefLength = ovector[1] - backrefStart;
259     } else if (ref == '`') {
260         backrefStart = 0;
261         backrefLength = ovector[0];
262     } else if (ref == '\'') {
263         backrefStart = ovector[1];
264         backrefLength = source.size() - backrefStart;
265     } else if (ref >= '0' && ref <= '9') {
266         // 1- and 2-digit back references are allowed
267         unsigned backrefIndex = ref - '0';
268         if (backrefIndex > reg->numSubpatterns())
269             continue;
270         if (substitutedReplacement.size() > i + 2) {
271             ref = substitutedReplacement[i+2];
272             if (ref >= '0' && ref <= '9') {
273                 backrefIndex = 10 * backrefIndex + ref - '0';
274                 if (backrefIndex > reg->numSubpatterns())
275                     backrefIndex = backrefIndex / 10;   // Fall back to the 1-digit reference
276                 else
277                     advance = 1;
278             }
279         }
280         backrefStart = ovector[2 * backrefIndex];
281         backrefLength = ovector[2 * backrefIndex + 1] - backrefStart;
282     } else
283         continue;
284
285     substitutedReplacement = substitutedReplacement.substr(0, i) + source.substr(backrefStart, backrefLength) + substitutedReplacement.substr(i + 2 + advance);
286     i += backrefLength - 1; // - 1 offsets 'i + 1'
287   }
288
289   return substitutedReplacement;
290 }
291
292 static inline int localeCompare(const UString& a, const UString& b)
293 {
294     return Collator::userDefault()->collate(reinterpret_cast<const ::UChar*>(a.data()), a.size(), reinterpret_cast<const ::UChar*>(b.data()), b.size());
295 }
296
297 static JSValue *replace(ExecState *exec, StringImp* sourceVal, JSValue *pattern, JSValue *replacement)
298 {
299   UString source = sourceVal->value();
300   JSObject *replacementFunction = 0;
301   UString replacementString;
302
303   if (replacement->isObject() && replacement->toObject(exec)->implementsCall())
304     replacementFunction = replacement->toObject(exec);
305   else
306     replacementString = replacement->toString(exec);
307
308   if (pattern->isObject() && static_cast<JSObject *>(pattern)->inherits(&RegExpImp::info)) {
309     RegExp *reg = static_cast<RegExpImp *>(pattern)->regExp();
310     bool global = reg->global();
311
312     RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->lexicalGlobalObject()->regExpConstructor());
313
314     int lastIndex = 0;
315     int startPosition = 0;
316
317     UString::Range *sourceRanges = 0;
318     int sourceRangeCount = 0;
319     int sourceRangeCapacity = 0;
320     UString *replacements = 0;
321     int replacementCount = 0;
322     int replacementCapacity = 0;
323
324     // This is either a loop (if global is set) or a one-way (if not).
325     do {
326       int matchIndex;
327       int matchLen;
328       int* ovector;
329       regExpObj->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector);
330       if (matchIndex < 0)
331         break;
332
333       pushSourceRange(sourceRanges, sourceRangeCount, sourceRangeCapacity, UString::Range(lastIndex, matchIndex - lastIndex));
334
335       UString substitutedReplacement;
336       if (replacementFunction) {
337           int completeMatchStart = ovector[0];
338           List args;
339
340           for (unsigned i = 0; i < reg->numSubpatterns() + 1; i++) {
341               int matchStart = ovector[i * 2];
342               int matchLen = ovector[i * 2 + 1] - matchStart;
343
344               if (matchStart < 0)
345                 args.append(jsUndefined());
346               else
347                 args.append(jsString(source.substr(matchStart, matchLen)));
348           }
349           
350           args.append(jsNumber(completeMatchStart));
351           args.append(sourceVal);
352
353           substitutedReplacement = replacementFunction->call(exec, exec->globalThisValue(), args)->toString(exec);
354       } else
355           substitutedReplacement = substituteBackreferences(replacementString, source, ovector, reg);
356
357       pushReplacement(replacements, replacementCount, replacementCapacity, substitutedReplacement);
358
359       lastIndex = matchIndex + matchLen;
360       startPosition = lastIndex;
361
362       // special case of empty match
363       if (matchLen == 0) {
364         startPosition++;
365         if (startPosition > source.size())
366           break;
367       }
368     } while (global);
369
370     if (lastIndex < source.size())
371       pushSourceRange(sourceRanges, sourceRangeCount, sourceRangeCapacity, UString::Range(lastIndex, source.size() - lastIndex));
372
373     UString result;
374
375     if (sourceRanges)
376         result = source.spliceSubstringsWithSeparators(sourceRanges, sourceRangeCount, replacements, replacementCount);
377
378     delete [] sourceRanges;
379     delete [] replacements;
380
381     if (result == source)
382       return sourceVal;
383
384     return jsString(result);
385   }
386   
387   // First arg is a string
388   UString patternString = pattern->toString(exec);
389   int matchPos = source.find(patternString);
390   int matchLen = patternString.size();
391   // Do the replacement
392   if (matchPos == -1)
393     return sourceVal;
394   
395   if (replacementFunction) {
396       List args;
397       
398       args.append(jsString(source.substr(matchPos, matchLen)));
399       args.append(jsNumber(matchPos));
400       args.append(sourceVal);
401       
402       replacementString = replacementFunction->call(exec, exec->globalThisValue(), args)->toString(exec);
403   }
404
405   return jsString(source.substr(0, matchPos) + replacementString + source.substr(matchPos + matchLen));
406 }
407
408 JSValue* stringProtoFuncToString(ExecState* exec, JSObject* thisObj, const List&)
409 {
410     if (!thisObj->inherits(&StringInstance::info))
411         return throwError(exec, TypeError);
412
413     return static_cast<StringInstance*>(thisObj)->internalValue();
414 }
415
416 JSValue* stringProtoFuncValueOf(ExecState* exec, JSObject* thisObj, const List&)
417 {
418     if (!thisObj->inherits(&StringInstance::info))
419         return throwError(exec, TypeError);
420
421     return static_cast<StringInstance*>(thisObj)->internalValue();
422 }
423
424 JSValue* stringProtoFuncCharAt(ExecState* exec, JSObject* thisObj, const List& args)
425 {
426     // This optimizes the common case that thisObj is a StringInstance
427     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
428     int len = s.size();
429
430     UString u;
431     JSValue* a0 = args[0];
432     double dpos = a0->toInteger(exec);
433     if (dpos >= 0 && dpos < len)
434       u = s.substr(static_cast<int>(dpos), 1);
435     else
436       u = "";
437     return jsString(u);
438 }
439
440 JSValue* stringProtoFuncCharCodeAt(ExecState* exec, JSObject* thisObj, const List& args)
441 {
442     // This optimizes the common case that thisObj is a StringInstance
443     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
444     int len = s.size();
445
446     JSValue* result = 0;
447
448     JSValue* a0 = args[0];
449     double dpos = a0->toInteger(exec);
450     if (dpos >= 0 && dpos < len)
451       result = jsNumber(s[static_cast<int>(dpos)]);
452     else
453       result = jsNaN();
454     return result;
455 }
456
457 JSValue* stringProtoFuncConcat(ExecState* exec, JSObject* thisObj, const List& args)
458 {
459     // This optimizes the common case that thisObj is a StringInstance
460     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
461
462     List::const_iterator end = args.end();
463     for (List::const_iterator it = args.begin(); it != end; ++it) {
464         s += (*it)->toString(exec);
465     }
466     return jsString(s);
467 }
468
469 JSValue* stringProtoFuncIndexOf(ExecState* exec, JSObject* thisObj, const List& args)
470 {
471     // This optimizes the common case that thisObj is a StringInstance
472     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
473     int len = s.size();
474
475     JSValue* a0 = args[0];
476     JSValue* a1 = args[1];
477     UString u2 = a0->toString(exec);
478     double dpos = a1->toInteger(exec);
479     if (dpos < 0)
480         dpos = 0;
481     else if (dpos > len)
482         dpos = len;
483     return jsNumber(s.find(u2, static_cast<int>(dpos)));
484 }
485
486 JSValue* stringProtoFuncLastIndexOf(ExecState* exec, JSObject* thisObj, const List& args)
487 {
488     // This optimizes the common case that thisObj is a StringInstance
489     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
490     int len = s.size();
491
492     JSValue* a0 = args[0];
493     JSValue* a1 = args[1];
494     
495     UString u2 = a0->toString(exec);
496     double dpos = a1->toIntegerPreserveNaN(exec);
497     if (dpos < 0)
498         dpos = 0;
499     else if (!(dpos <= len)) // true for NaN
500         dpos = len;
501     return jsNumber(s.rfind(u2, static_cast<int>(dpos)));
502 }
503
504 JSValue* stringProtoFuncMatch(ExecState* exec, JSObject* thisObj, const List& args)
505 {
506     // This optimizes the common case that thisObj is a StringInstance
507     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
508
509     JSValue* a0 = args[0];
510
511     UString u = s;
512     RefPtr<RegExp> reg;
513     RegExpImp* imp = 0;
514     if (a0->isObject() && static_cast<JSObject *>(a0)->inherits(&RegExpImp::info)) {
515       reg = static_cast<RegExpImp *>(a0)->regExp();
516     } else { 
517       /*
518        *  ECMA 15.5.4.12 String.prototype.search (regexp)
519        *  If regexp is not an object whose [[Class]] property is "RegExp", it is
520        *  replaced with the result of the expression new RegExp(regexp).
521        */
522       reg = RegExp::create(a0->toString(exec));
523     }
524     RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->lexicalGlobalObject()->regExpConstructor());
525     int pos;
526     int matchLength;
527     regExpObj->performMatch(reg.get(), u, 0, pos, matchLength);
528     JSValue* result;
529     if (!(reg->global())) {
530       // case without 'g' flag is handled like RegExp.prototype.exec
531       if (pos < 0)
532         result = jsNull();
533       else
534         result = regExpObj->arrayOfMatches(exec);
535     } else {
536       // return array of matches
537       List list;
538       int lastIndex = 0;
539       while (pos >= 0) {
540         list.append(jsString(u.substr(pos, matchLength)));
541         lastIndex = pos;
542         pos += matchLength == 0 ? 1 : matchLength;
543         regExpObj->performMatch(reg.get(), u, pos, pos, matchLength);
544       }
545       if (imp)
546         imp->setLastIndex(lastIndex);
547       if (list.isEmpty()) {
548         // if there are no matches at all, it's important to return
549         // Null instead of an empty array, because this matches
550         // other browsers and because Null is a false value.
551         result = jsNull();
552       } else {
553         result = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, list);
554       }
555     }
556     return result;
557 }
558
559 JSValue* stringProtoFuncSearch(ExecState* exec, JSObject* thisObj, const List& args)
560 {
561     // This optimizes the common case that thisObj is a StringInstance
562     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
563
564     JSValue* a0 = args[0];
565
566     UString u = s;
567     RefPtr<RegExp> reg;
568     if (a0->isObject() && static_cast<JSObject*>(a0)->inherits(&RegExpImp::info)) {
569       reg = static_cast<RegExpImp*>(a0)->regExp();
570     } else { 
571       /*
572        *  ECMA 15.5.4.12 String.prototype.search (regexp)
573        *  If regexp is not an object whose [[Class]] property is "RegExp", it is
574        *  replaced with the result of the expression new RegExp(regexp).
575        */
576       reg = RegExp::create(a0->toString(exec));
577     }
578     RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->lexicalGlobalObject()->regExpConstructor());
579     int pos;
580     int matchLength;
581     regExpObj->performMatch(reg.get(), u, 0, pos, matchLength);
582     return jsNumber(pos);
583 }
584
585 JSValue* stringProtoFuncReplace(ExecState* exec, JSObject* thisObj, const List& args)
586 {
587     // This optimizes the common case that thisObj is a StringInstance
588     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
589
590     StringImp* sVal = thisObj->inherits(&StringInstance::info) ?
591       static_cast<StringInstance*>(thisObj)->internalValue() :
592       static_cast<StringImp*>(jsString(s));
593
594     JSValue* a0 = args[0];
595     JSValue* a1 = args[1];
596
597     return replace(exec, sVal, a0, a1);
598 }
599
600 JSValue* stringProtoFuncSlice(ExecState* exec, JSObject* thisObj, const List& args)
601 {
602     // This optimizes the common case that thisObj is a StringInstance
603     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
604     int len = s.size();
605
606     JSValue* a0 = args[0];
607     JSValue* a1 = args[1];
608
609     // The arg processing is very much like ArrayProtoFunc::Slice
610     double start = a0->toInteger(exec);
611     double end = a1->isUndefined() ? len : a1->toInteger(exec);
612     double from = start < 0 ? len + start : start;
613     double to = end < 0 ? len + end : end;
614     if (to > from && to > 0 && from < len) {
615         if (from < 0)
616             from = 0;
617         if (to > len)
618             to = len;
619         return jsString(s.substr(static_cast<int>(from), static_cast<int>(to - from)));
620     }
621
622     return jsString("");
623 }
624
625 JSValue* stringProtoFuncSplit(ExecState* exec, JSObject* thisObj, const List& args)
626 {
627     // This optimizes the common case that thisObj is a StringInstance
628     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
629
630     JSValue* a0 = args[0];
631     JSValue* a1 = args[1];
632
633     JSObject *constructor = exec->lexicalGlobalObject()->arrayConstructor();
634     JSObject* res = static_cast<JSObject*>(constructor->construct(exec, exec->emptyList()));
635     JSValue* result = res;
636     UString u = s;
637     int pos;
638     int i = 0;
639     int p0 = 0;
640     uint32_t limit = a1->isUndefined() ? 0xFFFFFFFFU : a1->toUInt32(exec);
641     if (a0->isObject() && static_cast<JSObject *>(a0)->inherits(&RegExpImp::info)) {
642       RegExp *reg = static_cast<RegExpImp *>(a0)->regExp();
643       if (u.isEmpty() && reg->match(u, 0) >= 0) {
644         // empty string matched by regexp -> empty array
645         res->put(exec, exec->propertyNames().length, jsNumber(0));
646         return result;
647       }
648       pos = 0;
649       while (static_cast<uint32_t>(i) != limit && pos < u.size()) {
650         OwnArrayPtr<int> ovector;
651         int mpos = reg->match(u, pos, &ovector);
652         if (mpos < 0)
653           break;
654         int mlen = ovector[1] - ovector[0];
655         pos = mpos + (mlen == 0 ? 1 : mlen);
656         if (mpos != p0 || mlen) {
657           res->put(exec,i, jsString(u.substr(p0, mpos-p0)));
658           p0 = mpos + mlen;
659           i++;
660         }
661         for (unsigned si = 1; si <= reg->numSubpatterns(); ++si) {
662           int spos = ovector[si * 2];
663           if (spos < 0)
664             res->put(exec, i++, jsUndefined());
665           else
666             res->put(exec, i++, jsString(u.substr(spos, ovector[si * 2 + 1] - spos)));
667         }
668       }
669     } else {
670       UString u2 = a0->toString(exec);
671       if (u2.isEmpty()) {
672         if (u.isEmpty()) {
673           // empty separator matches empty string -> empty array
674           res->put(exec, exec->propertyNames().length, jsNumber(0));
675           return result;
676         } else {
677           while (static_cast<uint32_t>(i) != limit && i < u.size()-1)
678             res->put(exec, i++, jsString(u.substr(p0++, 1)));
679         }
680       } else {
681         while (static_cast<uint32_t>(i) != limit && (pos = u.find(u2, p0)) >= 0) {
682           res->put(exec, i, jsString(u.substr(p0, pos-p0)));
683           p0 = pos + u2.size();
684           i++;
685         }
686       }
687     }
688     // add remaining string, if any
689     if (static_cast<uint32_t>(i) != limit)
690       res->put(exec, i++, jsString(u.substr(p0)));
691     res->put(exec, exec->propertyNames().length, jsNumber(i));
692     return result;
693 }
694
695 JSValue* stringProtoFuncSubstr(ExecState* exec, JSObject* thisObj, const List& args)
696 {
697     // This optimizes the common case that thisObj is a StringInstance
698     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
699     int len = s.size();
700
701     JSValue* a0 = args[0];
702     JSValue* a1 = args[1];
703
704     double start = a0->toInteger(exec);
705     double length = a1->isUndefined() ? len : a1->toInteger(exec);
706     if (start >= len)
707       return jsString("");
708     if (length < 0)
709       return jsString("");
710     if (start < 0) {
711       start += len;
712       if (start < 0)
713         start = 0;
714     }
715     if (length > len)
716       length = len;
717     return jsString(s.substr(static_cast<int>(start), static_cast<int>(length)));
718 }
719
720 JSValue* stringProtoFuncSubstring(ExecState* exec, JSObject* thisObj, const List& args)
721 {
722     // This optimizes the common case that thisObj is a StringInstance
723     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
724     int len = s.size();
725
726     JSValue* a0 = args[0];
727     JSValue* a1 = args[1];
728
729     double start = a0->toNumber(exec);
730     double end = a1->toNumber(exec);
731     if (isnan(start))
732       start = 0;
733     if (isnan(end))
734       end = 0;
735     if (start < 0)
736       start = 0;
737     if (end < 0)
738       end = 0;
739     if (start > len)
740       start = len;
741     if (end > len)
742       end = len;
743     if (a1->isUndefined())
744       end = len;
745     if (start > end) {
746       double temp = end;
747       end = start;
748       start = temp;
749     }
750     return jsString(s.substr((int)start, (int)end-(int)start));
751 }
752
753 JSValue* stringProtoFuncToLowerCase(ExecState* exec, JSObject* thisObj, const List&)
754 {
755     // This optimizes the common case that thisObj is a StringInstance
756     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
757     
758     StringImp* sVal = thisObj->inherits(&StringInstance::info)
759         ? static_cast<StringInstance*>(thisObj)->internalValue()
760         : static_cast<StringImp*>(jsString(s));
761     int ssize = s.size();
762     if (!ssize)
763         return sVal;
764     Vector<UChar> buffer(ssize);
765     bool error;
766     int length = Unicode::toLower(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
767     if (error) {
768         buffer.resize(length);
769         length = Unicode::toLower(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
770         if (error)
771             return sVal;
772     }
773     if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0)
774         return sVal;
775     return jsString(UString(buffer.releaseBuffer(), length, false));
776 }
777
778 JSValue* stringProtoFuncToUpperCase(ExecState* exec, JSObject* thisObj, const List&)
779 {
780     // This optimizes the common case that thisObj is a StringInstance
781     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
782
783     StringImp* sVal = thisObj->inherits(&StringInstance::info)
784         ? static_cast<StringInstance*>(thisObj)->internalValue()
785         : static_cast<StringImp*>(jsString(s));
786     int ssize = s.size();
787     if (!ssize)
788         return sVal;
789     Vector<UChar> buffer(ssize);
790     bool error;
791     int length = Unicode::toUpper(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
792     if (error) {
793         buffer.resize(length);
794         length = Unicode::toUpper(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
795         if (error)
796             return sVal;
797     }
798     if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0)
799         return sVal;
800     return jsString(UString(buffer.releaseBuffer(), length, false));
801 }
802
803 JSValue* stringProtoFuncToLocaleLowerCase(ExecState* exec, JSObject* thisObj, const List&)
804 {
805     // This optimizes the common case that thisObj is a StringInstance
806     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
807     
808     // FIXME: See http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt for locale-sensitive mappings that aren't implemented.
809     StringImp* sVal = thisObj->inherits(&StringInstance::info)
810         ? static_cast<StringInstance*>(thisObj)->internalValue()
811         : static_cast<StringImp*>(jsString(s));
812     int ssize = s.size();
813     if (!ssize)
814         return sVal;
815     Vector<UChar> buffer(ssize);
816     bool error;
817     int length = Unicode::toLower(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
818     if (error) {
819         buffer.resize(length);
820         length = Unicode::toLower(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
821         if (error)
822             return sVal;
823     }
824     if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0)
825         return sVal;
826     return jsString(UString(buffer.releaseBuffer(), length, false));
827 }
828
829 JSValue* stringProtoFuncToLocaleUpperCase(ExecState* exec, JSObject* thisObj, const List&)
830 {
831     // This optimizes the common case that thisObj is a StringInstance
832     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
833
834     StringImp* sVal = thisObj->inherits(&StringInstance::info)
835         ? static_cast<StringInstance*>(thisObj)->internalValue()
836         : static_cast<StringImp*>(jsString(s));
837     int ssize = s.size();
838     if (!ssize)
839         return sVal;
840     Vector<UChar> buffer(ssize);
841     bool error;
842     int length = Unicode::toUpper(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
843     if (error) {
844         buffer.resize(length);
845         length = Unicode::toUpper(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error);
846         if (error)
847             return sVal;
848     }
849     if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0)
850         return sVal;
851     return jsString(UString(buffer.releaseBuffer(), length, false));
852 }
853
854 JSValue* stringProtoFuncLocaleCompare(ExecState* exec, JSObject* thisObj, const List& args)
855 {
856     if (args.size() < 1)
857       return jsNumber(0);
858
859     // This optimizes the common case that thisObj is a StringInstance
860     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
861     JSValue* a0 = args[0];
862     return jsNumber(localeCompare(s, a0->toString(exec)));
863 }
864
865 JSValue* stringProtoFuncBig(ExecState* exec, JSObject* thisObj, const List&)
866 {
867     // This optimizes the common case that thisObj is a StringInstance
868     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
869     return jsString("<big>" + s + "</big>");
870 }
871
872 JSValue* stringProtoFuncSmall(ExecState* exec, JSObject* thisObj, const List&)
873 {
874     // This optimizes the common case that thisObj is a StringInstance
875     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
876     return jsString("<small>" + s + "</small>");
877 }
878
879 JSValue* stringProtoFuncBlink(ExecState* exec, JSObject* thisObj, const List&)
880 {
881     // This optimizes the common case that thisObj is a StringInstance
882     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
883     return jsString("<blink>" + s + "</blink>");
884 }
885
886 JSValue* stringProtoFuncBold(ExecState* exec, JSObject* thisObj, const List&)
887 {
888     // This optimizes the common case that thisObj is a StringInstance
889     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
890     return jsString("<b>" + s + "</b>");
891 }
892
893 JSValue* stringProtoFuncFixed(ExecState* exec, JSObject* thisObj, const List&)
894 {
895     // This optimizes the common case that thisObj is a StringInstance
896     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
897     return jsString("<tt>" + s + "</tt>");
898 }
899
900 JSValue* stringProtoFuncItalics(ExecState* exec, JSObject* thisObj, const List&)
901 {
902     // This optimizes the common case that thisObj is a StringInstance
903     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
904     return jsString("<i>" + s + "</i>");
905 }
906
907 JSValue* stringProtoFuncStrike(ExecState* exec, JSObject* thisObj, const List&)
908 {
909     // This optimizes the common case that thisObj is a StringInstance
910     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
911     return jsString("<strike>" + s + "</strike>");
912 }
913
914 JSValue* stringProtoFuncSub(ExecState* exec, JSObject* thisObj, const List&)
915 {
916     // This optimizes the common case that thisObj is a StringInstance
917     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
918     return jsString("<sub>" + s + "</sub>");
919 }
920
921 JSValue* stringProtoFuncSup(ExecState* exec, JSObject* thisObj, const List&)
922 {
923     // This optimizes the common case that thisObj is a StringInstance
924     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
925     return jsString("<sup>" + s + "</sup>");
926 }
927
928 JSValue* stringProtoFuncFontcolor(ExecState* exec, JSObject* thisObj, const List& args)
929 {
930     // This optimizes the common case that thisObj is a StringInstance
931     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
932     JSValue* a0 = args[0];
933     return jsString("<font color=\"" + a0->toString(exec) + "\">" + s + "</font>");
934 }
935
936 JSValue* stringProtoFuncFontsize(ExecState* exec, JSObject* thisObj, const List& args)
937 {
938     // This optimizes the common case that thisObj is a StringInstance
939     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
940     JSValue* a0 = args[0];
941     return jsString("<font size=\"" + a0->toString(exec) + "\">" + s + "</font>");
942 }
943
944 JSValue* stringProtoFuncAnchor(ExecState* exec, JSObject* thisObj, const List& args)
945 {
946     // This optimizes the common case that thisObj is a StringInstance
947     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
948     JSValue* a0 = args[0];
949     return jsString("<a name=\"" + a0->toString(exec) + "\">" + s + "</a>");
950 }
951
952 JSValue* stringProtoFuncLink(ExecState* exec, JSObject* thisObj, const List& args)
953 {
954     // This optimizes the common case that thisObj is a StringInstance
955     UString s = thisObj->inherits(&StringInstance::info) ? static_cast<StringInstance*>(thisObj)->internalValue()->value() : thisObj->toString(exec);
956     JSValue* a0 = args[0];
957     return jsString("<a href=\"" + a0->toString(exec) + "\">" + s + "</a>");
958 }
959
960 // ------------------------------ StringObjectImp ------------------------------
961
962 StringObjectImp::StringObjectImp(ExecState* exec, FunctionPrototype* funcProto, StringPrototype* stringProto)
963   : InternalFunctionImp(funcProto, stringProto->classInfo()->className)
964 {
965   // ECMA 15.5.3.1 String.prototype
966   putDirect(exec->propertyNames().prototype, stringProto, DontEnum|DontDelete|ReadOnly);
967
968   putDirectFunction(new StringObjectFuncImp(exec, funcProto, exec->propertyNames().fromCharCode), DontEnum);
969
970   // no. of arguments for constructor
971   putDirect(exec->propertyNames().length, jsNumber(1), ReadOnly|DontDelete|DontEnum);
972 }
973
974
975 bool StringObjectImp::implementsConstruct() const
976 {
977   return true;
978 }
979
980 // ECMA 15.5.2
981 JSObject *StringObjectImp::construct(ExecState *exec, const List &args)
982 {
983   JSObject *proto = exec->lexicalGlobalObject()->stringPrototype();
984   if (args.size() == 0)
985     return new StringInstance(proto);
986   return new StringInstance(proto, args[0]->toString(exec));
987 }
988
989 // ECMA 15.5.1
990 JSValue *StringObjectImp::callAsFunction(ExecState *exec, JSObject* /*thisObj*/, const List &args)
991 {
992   if (args.isEmpty())
993     return jsString("");
994   else {
995     JSValue *v = args[0];
996     return jsString(v->toString(exec));
997   }
998 }
999
1000 // ------------------------------ StringObjectFuncImp --------------------------
1001
1002 // ECMA 15.5.3.2 fromCharCode()
1003 StringObjectFuncImp::StringObjectFuncImp(ExecState* exec, FunctionPrototype* funcProto, const Identifier& name)
1004   : InternalFunctionImp(funcProto, name)
1005 {
1006   putDirect(exec->propertyNames().length, jsNumber(1), DontDelete|ReadOnly|DontEnum);
1007 }
1008
1009 JSValue *StringObjectFuncImp::callAsFunction(ExecState *exec, JSObject* /*thisObj*/, const List &args)
1010 {
1011   UString s;
1012   if (args.size()) {
1013     UChar *buf = static_cast<UChar *>(fastMalloc(args.size() * sizeof(UChar)));
1014     UChar *p = buf;
1015     List::const_iterator end = args.end();
1016     for (List::const_iterator it = args.begin(); it != end; ++it) {
1017       unsigned short u = static_cast<unsigned short>((*it)->toUInt32(exec));
1018       *p++ = UChar(u);
1019     }
1020     s = UString(buf, args.size(), false);
1021   } else
1022     s = "";
1023
1024   return jsString(s);
1025 }
1026
1027 } // namespace KJS