6a5ea8b93885067f273c195a734be654de527e5f
[WebKit.git] / JavaScriptCore / runtime / UString.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
5  *  Copyright (c) 2009, Google Inc. All rights reserved.
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Library General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Library General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Library General Public License
18  *  along with this library; see the file COPYING.LIB.  If not, write to
19  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  *  Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #include "config.h"
25 #include "UString.h"
26
27 #include "JSGlobalObjectFunctions.h"
28 #include "Collector.h"
29 #include "dtoa.h"
30 #include "Identifier.h"
31 #include "Operations.h"
32 #include <ctype.h>
33 #include <float.h>
34 #include <limits.h>
35 #include <math.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <wtf/ASCIICType.h>
39 #include <wtf/Assertions.h>
40 #include <wtf/MathExtras.h>
41 #include <wtf/Vector.h>
42 #include <wtf/unicode/UTF8.h>
43
44 #if HAVE(STRING_H)
45 #include <string.h>
46 #endif
47 #if HAVE(STRINGS_H)
48 #include <strings.h>
49 #endif
50
51 using namespace WTF;
52 using namespace WTF::Unicode;
53 using namespace std;
54
55 // This can be tuned differently per platform by putting platform #ifs right here.
56 // If you don't define this macro at all, then copyChars will just call directly
57 // to memcpy.
58 #define USTRING_COPY_CHARS_INLINE_CUTOFF 20
59
60 namespace JSC {
61  
62 extern const double NaN;
63 extern const double Inf;
64
65 static inline size_t overflowIndicator() { return std::numeric_limits<size_t>::max(); }
66 static inline size_t maxUChars() { return std::numeric_limits<size_t>::max() / sizeof(UChar); }
67
68 static inline UChar* allocChars(size_t length)
69 {
70     ASSERT(length);
71     if (length > maxUChars())
72         return 0;
73     return static_cast<UChar*>(tryFastMalloc(sizeof(UChar) * length));
74 }
75
76 static inline UChar* reallocChars(UChar* buffer, size_t length)
77 {
78     ASSERT(length);
79     if (length > maxUChars())
80         return 0;
81     return static_cast<UChar*>(tryFastRealloc(buffer, sizeof(UChar) * length));
82 }
83
84 static inline void copyChars(UChar* destination, const UChar* source, unsigned numCharacters)
85 {
86 #ifdef USTRING_COPY_CHARS_INLINE_CUTOFF
87     if (numCharacters <= USTRING_COPY_CHARS_INLINE_CUTOFF) {
88         for (unsigned i = 0; i < numCharacters; ++i)
89             destination[i] = source[i];
90         return;
91     }
92 #endif
93     memcpy(destination, source, numCharacters * sizeof(UChar));
94 }
95
96 COMPILE_ASSERT(sizeof(UChar) == 2, uchar_is_2_bytes);
97
98 CString::CString(const char* c)
99     : m_length(strlen(c))
100     , m_data(new char[m_length + 1])
101 {
102     memcpy(m_data, c, m_length + 1);
103 }
104
105 CString::CString(const char* c, size_t length)
106     : m_length(length)
107     , m_data(new char[length + 1])
108 {
109     memcpy(m_data, c, m_length);
110     m_data[m_length] = 0;
111 }
112
113 CString::CString(const CString& b)
114 {
115     m_length = b.m_length;
116     if (b.m_data) {
117         m_data = new char[m_length + 1];
118         memcpy(m_data, b.m_data, m_length + 1);
119     } else
120         m_data = 0;
121 }
122
123 CString::~CString()
124 {
125     delete [] m_data;
126 }
127
128 CString CString::adopt(char* c, size_t length)
129 {
130     CString s;
131     s.m_data = c;
132     s.m_length = length;
133     return s;
134 }
135
136 CString& CString::append(const CString& t)
137 {
138     char* n;
139     n = new char[m_length + t.m_length + 1];
140     if (m_length)
141         memcpy(n, m_data, m_length);
142     if (t.m_length)
143         memcpy(n + m_length, t.m_data, t.m_length);
144     m_length += t.m_length;
145     n[m_length] = 0;
146
147     delete [] m_data;
148     m_data = n;
149
150     return *this;
151 }
152
153 CString& CString::operator=(const char* c)
154 {
155     if (m_data)
156         delete [] m_data;
157     m_length = strlen(c);
158     m_data = new char[m_length + 1];
159     memcpy(m_data, c, m_length + 1);
160
161     return *this;
162 }
163
164 CString& CString::operator=(const CString& str)
165 {
166     if (this == &str)
167         return *this;
168
169     if (m_data)
170         delete [] m_data;
171     m_length = str.m_length;
172     if (str.m_data) {
173         m_data = new char[m_length + 1];
174         memcpy(m_data, str.m_data, m_length + 1);
175     } else
176         m_data = 0;
177
178     return *this;
179 }
180
181 bool operator==(const CString& c1, const CString& c2)
182 {
183     size_t len = c1.size();
184     return len == c2.size() && (len == 0 || memcmp(c1.c_str(), c2.c_str(), len) == 0);
185 }
186
187 // These static strings are immutable, except for rc, whose initial value is chosen to 
188 // reduce the possibility of it becoming zero due to ref/deref not being thread-safe.
189 static UChar sharedEmptyChar;
190 UString::BaseString* UString::Rep::nullBaseString;
191 UString::BaseString* UString::Rep::emptyBaseString;
192 UString* UString::nullUString;
193
194 static void initializeStaticBaseString(UString::BaseString& base)
195 {
196     base.rc = INT_MAX / 2;
197     base.m_identifierTableAndFlags.setFlag(UString::Rep::StaticFlag);
198     base.checkConsistency();
199 }
200
201 void initializeUString()
202 {
203     UString::Rep::nullBaseString = new UString::BaseString(0, 0);
204     initializeStaticBaseString(*UString::Rep::nullBaseString);
205
206     UString::Rep::emptyBaseString = new UString::BaseString(&sharedEmptyChar, 0);
207     initializeStaticBaseString(*UString::Rep::emptyBaseString);
208
209     UString::nullUString = new UString;
210 }
211
212 static char* statBuffer = 0; // Only used for debugging via UString::ascii().
213
214 PassRefPtr<UString::Rep> UString::Rep::createCopying(const UChar* d, int l)
215 {
216     UChar* copyD = static_cast<UChar*>(fastMalloc(l * sizeof(UChar)));
217     copyChars(copyD, d, l);
218     return create(copyD, l);
219 }
220
221 PassRefPtr<UString::Rep> UString::Rep::createFromUTF8(const char* string)
222 {
223     if (!string)
224         return &UString::Rep::null();
225
226     size_t length = strlen(string);
227     Vector<UChar, 1024> buffer(length);
228     UChar* p = buffer.data();
229     if (conversionOK != convertUTF8ToUTF16(&string, string + length, &p, p + length))
230         return &UString::Rep::null();
231
232     return UString::Rep::createCopying(buffer.data(), p - buffer.data());
233 }
234
235 void UString::Rep::destroy()
236 {
237     checkConsistency();
238
239     // Static null and empty strings can never be destroyed, but we cannot rely on 
240     // reference counting, because ref/deref are not thread-safe.
241     if (!isStatic()) {
242         if (identifierTable())
243             Identifier::remove(this);
244         UString::BaseString* base = baseString();
245         if (base == this)
246             fastFree(base->buf);
247         else
248             base->deref();
249
250         delete this;
251     }
252 }
253
254 // Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's
255 // or anything like that.
256 const unsigned PHI = 0x9e3779b9U;
257
258 // Paul Hsieh's SuperFastHash
259 // http://www.azillionmonkeys.com/qed/hash.html
260 unsigned UString::Rep::computeHash(const UChar* s, int len)
261 {
262     unsigned l = len;
263     uint32_t hash = PHI;
264     uint32_t tmp;
265
266     int rem = l & 1;
267     l >>= 1;
268
269     // Main loop
270     for (; l > 0; l--) {
271         hash += s[0];
272         tmp = (s[1] << 11) ^ hash;
273         hash = (hash << 16) ^ tmp;
274         s += 2;
275         hash += hash >> 11;
276     }
277
278     // Handle end case
279     if (rem) {
280         hash += s[0];
281         hash ^= hash << 11;
282         hash += hash >> 17;
283     }
284
285     // Force "avalanching" of final 127 bits
286     hash ^= hash << 3;
287     hash += hash >> 5;
288     hash ^= hash << 2;
289     hash += hash >> 15;
290     hash ^= hash << 10;
291
292     // this avoids ever returning a hash code of 0, since that is used to
293     // signal "hash not computed yet", using a value that is likely to be
294     // effectively the same as 0 when the low bits are masked
295     if (hash == 0)
296         hash = 0x80000000;
297
298     return hash;
299 }
300
301 // Paul Hsieh's SuperFastHash
302 // http://www.azillionmonkeys.com/qed/hash.html
303 unsigned UString::Rep::computeHash(const char* s, int l)
304 {
305     // This hash is designed to work on 16-bit chunks at a time. But since the normal case
306     // (above) is to hash UTF-16 characters, we just treat the 8-bit chars as if they
307     // were 16-bit chunks, which should give matching results
308
309     uint32_t hash = PHI;
310     uint32_t tmp;
311
312     size_t rem = l & 1;
313     l >>= 1;
314
315     // Main loop
316     for (; l > 0; l--) {
317         hash += static_cast<unsigned char>(s[0]);
318         tmp = (static_cast<unsigned char>(s[1]) << 11) ^ hash;
319         hash = (hash << 16) ^ tmp;
320         s += 2;
321         hash += hash >> 11;
322     }
323
324     // Handle end case
325     if (rem) {
326         hash += static_cast<unsigned char>(s[0]);
327         hash ^= hash << 11;
328         hash += hash >> 17;
329     }
330
331     // Force "avalanching" of final 127 bits
332     hash ^= hash << 3;
333     hash += hash >> 5;
334     hash ^= hash << 2;
335     hash += hash >> 15;
336     hash ^= hash << 10;
337
338     // this avoids ever returning a hash code of 0, since that is used to
339     // signal "hash not computed yet", using a value that is likely to be
340     // effectively the same as 0 when the low bits are masked
341     if (hash == 0)
342         hash = 0x80000000;
343
344     return hash;
345 }
346
347 #ifndef NDEBUG
348 void UString::Rep::checkConsistency() const
349 {
350     const UString::BaseString* base = baseString();
351
352     // There is no recursion for base strings.
353     ASSERT(base == base->baseString());
354
355     if (isStatic()) {
356         // There are only two static strings: null and empty.
357         ASSERT(!len);
358
359         // Static strings cannot get in identifier tables, because they are globally shared.
360         ASSERT(!identifierTable());
361     }
362
363     // The string fits in buffer.
364     ASSERT(base->usedPreCapacity <= base->preCapacity);
365     ASSERT(base->usedCapacity <= base->capacity);
366     ASSERT(-offset <= base->usedPreCapacity);
367     ASSERT(offset + len <= base->usedCapacity);
368 }
369 #endif
370
371 // put these early so they can be inlined
372 static inline size_t expandedSize(size_t size, size_t otherSize)
373 {
374     // Do the size calculation in two parts, returning overflowIndicator if
375     // we overflow the maximum value that we can handle.
376
377     if (size > maxUChars())
378         return overflowIndicator();
379
380     size_t expandedSize = ((size + 10) / 10 * 11) + 1;
381     if (maxUChars() - expandedSize < otherSize)
382         return overflowIndicator();
383
384     return expandedSize + otherSize;
385 }
386
387 static inline bool expandCapacity(UString::Rep* rep, int requiredLength)
388 {
389     rep->checkConsistency();
390
391     UString::BaseString* base = rep->baseString();
392
393     if (requiredLength > base->capacity) {
394         size_t newCapacity = expandedSize(requiredLength, base->preCapacity);
395         UChar* oldBuf = base->buf;
396         base->buf = reallocChars(base->buf, newCapacity);
397         if (!base->buf) {
398             base->buf = oldBuf;
399             return false;
400         }
401         base->capacity = newCapacity - base->preCapacity;
402     }
403     if (requiredLength > base->usedCapacity)
404         base->usedCapacity = requiredLength;
405
406     rep->checkConsistency();
407     return true;
408 }
409
410 void UString::expandCapacity(int requiredLength)
411 {
412     if (!JSC::expandCapacity(m_rep.get(), requiredLength))
413         makeNull();
414 }
415
416 void UString::expandPreCapacity(int requiredPreCap)
417 {
418     m_rep->checkConsistency();
419
420     BaseString* base = m_rep->baseString();
421
422     if (requiredPreCap > base->preCapacity) {
423         size_t newCapacity = expandedSize(requiredPreCap, base->capacity);
424         int delta = newCapacity - base->capacity - base->preCapacity;
425
426         UChar* newBuf = allocChars(newCapacity);
427         if (!newBuf) {
428             makeNull();
429             return;
430         }
431         copyChars(newBuf + delta, base->buf, base->capacity + base->preCapacity);
432         fastFree(base->buf);
433         base->buf = newBuf;
434
435         base->preCapacity = newCapacity - base->capacity;
436     }
437     if (requiredPreCap > base->usedPreCapacity)
438         base->usedPreCapacity = requiredPreCap;
439
440     m_rep->checkConsistency();
441 }
442
443 static PassRefPtr<UString::Rep> createRep(const char* c)
444 {
445     if (!c)
446         return &UString::Rep::null();
447
448     if (!c[0])
449         return &UString::Rep::empty();
450
451     size_t length = strlen(c);
452     UChar* d = allocChars(length);
453     if (!d)
454         return &UString::Rep::null();
455     else {
456         for (size_t i = 0; i < length; i++)
457             d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
458         return UString::Rep::create(d, static_cast<int>(length));
459     }
460
461 }
462
463 UString::UString(const char* c)
464     : m_rep(createRep(c))
465 {
466 }
467
468 UString::UString(const UChar* c, int length)
469 {
470     if (length == 0) 
471         m_rep = &Rep::empty();
472     else
473         m_rep = Rep::createCopying(c, length);
474 }
475
476 UString::UString(UChar* c, int length, bool copy)
477 {
478     if (length == 0)
479         m_rep = &Rep::empty();
480     else if (copy)
481         m_rep = Rep::createCopying(c, length);
482     else
483         m_rep = Rep::create(c, length);
484 }
485
486 UString::UString(const Vector<UChar>& buffer)
487 {
488     if (!buffer.size())
489         m_rep = &Rep::empty();
490     else
491         m_rep = Rep::createCopying(buffer.data(), buffer.size());
492 }
493
494 static ALWAYS_INLINE int newCapacityWithOverflowCheck(const int currentCapacity, const int extendLength, const bool plusOne = false)
495 {
496     ASSERT_WITH_MESSAGE(extendLength >= 0, "extendedLength = %d", extendLength);
497
498     const int plusLength = plusOne ? 1 : 0;
499     if (currentCapacity > std::numeric_limits<int>::max() - extendLength - plusLength)
500         CRASH();
501
502     return currentCapacity + extendLength + plusLength;
503 }
504
505 static ALWAYS_INLINE PassRefPtr<UString::Rep> concatenate(PassRefPtr<UString::Rep> r, const UChar* tData, int tSize)
506 {
507     RefPtr<UString::Rep> rep = r;
508
509     rep->checkConsistency();
510
511     int thisSize = rep->size();
512     int thisOffset = rep->offset;
513     int length = thisSize + tSize;
514     UString::BaseString* base = rep->baseString();
515
516     // possible cases:
517     if (tSize == 0) {
518         // t is empty
519     } else if (thisSize == 0) {
520         // this is empty
521         rep = UString::Rep::createCopying(tData, tSize);
522     } else if (rep == base && !base->isShared()) {
523         // this is direct and has refcount of 1 (so we can just alter it directly)
524         if (!expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length)))
525             rep = &UString::Rep::null();
526         if (rep->data()) {
527             copyChars(rep->data() + thisSize, tData, tSize);
528             rep->len = length;
529             rep->_hash = 0;
530         }
531     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
532         // this reaches the end of the buffer - extend it if it's long enough to append to
533         if (!expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length)))
534             rep = &UString::Rep::null();
535         if (rep->data()) {
536             copyChars(rep->data() + thisSize, tData, tSize);
537             rep = UString::Rep::create(rep, 0, length);
538         }
539     } else {
540         // this is shared with someone using more capacity, gotta make a whole new string
541         size_t newCapacity = expandedSize(length, 0);
542         UChar* d = allocChars(newCapacity);
543         if (!d)
544             rep = &UString::Rep::null();
545         else {
546             copyChars(d, rep->data(), thisSize);
547             copyChars(d + thisSize, tData, tSize);
548             rep = UString::Rep::create(d, length);
549             rep->baseString()->capacity = newCapacity;
550         }
551     }
552
553     rep->checkConsistency();
554
555     return rep.release();
556 }
557
558 static ALWAYS_INLINE PassRefPtr<UString::Rep> concatenate(PassRefPtr<UString::Rep> r, const char* t)
559 {
560     RefPtr<UString::Rep> rep = r;
561
562     rep->checkConsistency();
563
564     int thisSize = rep->size();
565     int thisOffset = rep->offset;
566     int tSize = static_cast<int>(strlen(t));
567     int length = thisSize + tSize;
568     UString::BaseString* base = rep->baseString();
569
570     // possible cases:
571     if (thisSize == 0) {
572         // this is empty
573         rep = createRep(t);
574     } else if (tSize == 0) {
575         // t is empty, we'll just return *this below.
576     } else if (rep == base && !base->isShared()) {
577         // this is direct and has refcount of 1 (so we can just alter it directly)
578         expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length));
579         UChar* d = rep->data();
580         if (d) {
581             for (int i = 0; i < tSize; ++i)
582                 d[thisSize + i] = static_cast<unsigned char>(t[i]); // use unsigned char to zero-extend instead of sign-extend
583             rep->len = length;
584             rep->_hash = 0;
585         }
586     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
587         // this string reaches the end of the buffer - extend it
588         expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length));
589         UChar* d = rep->data();
590         if (d) {
591             for (int i = 0; i < tSize; ++i)
592                 d[thisSize + i] = static_cast<unsigned char>(t[i]); // use unsigned char to zero-extend instead of sign-extend
593             rep = UString::Rep::create(rep, 0, length);
594         }
595     } else {
596         // this is shared with someone using more capacity, gotta make a whole new string
597         size_t newCapacity = expandedSize(length, 0);
598         UChar* d = allocChars(newCapacity);
599         if (!d)
600             rep = &UString::Rep::null();
601         else {
602             copyChars(d, rep->data(), thisSize);
603             for (int i = 0; i < tSize; ++i)
604                 d[thisSize + i] = static_cast<unsigned char>(t[i]); // use unsigned char to zero-extend instead of sign-extend
605             rep = UString::Rep::create(d, length);
606             rep->baseString()->capacity = newCapacity;
607         }
608     }
609
610     rep->checkConsistency();
611
612     return rep.release();
613 }
614
615 PassRefPtr<UString::Rep> concatenate(UString::Rep* a, UString::Rep* b)
616 {
617     a->checkConsistency();
618     b->checkConsistency();
619
620     int aSize = a->size();
621     int bSize = b->size();
622     int aOffset = a->offset;
623
624     // possible cases:
625
626     UString::BaseString* aBase = a->baseString();
627     if (bSize == 1 && aOffset + aSize == aBase->usedCapacity && aOffset + aSize < aBase->capacity) {
628         // b is a single character (common fast case)
629         ++aBase->usedCapacity;
630         a->data()[aSize] = b->data()[0];
631         return UString::Rep::create(a, 0, aSize + 1);
632     }
633
634     // a is empty
635     if (aSize == 0)
636         return b;
637     // b is empty
638     if (bSize == 0)
639         return a;
640
641     int bOffset = b->offset;
642     int length = aSize + bSize;
643
644     UString::BaseString* bBase = b->baseString();
645     if (aOffset + aSize == aBase->usedCapacity && aSize >= minShareSize && 4 * aSize >= bSize
646         && (-bOffset != bBase->usedPreCapacity || aSize >= bSize)) {
647         // - a reaches the end of its buffer so it qualifies for shared append
648         // - also, it's at least a quarter the length of b - appending to a much shorter
649         //   string does more harm than good
650         // - however, if b qualifies for prepend and is longer than a, we'd rather prepend
651         
652         UString x(a);
653         x.expandCapacity(newCapacityWithOverflowCheck(aOffset, length));
654         if (!a->data() || !x.data())
655             return 0;
656         copyChars(a->data() + aSize, b->data(), bSize);
657         PassRefPtr<UString::Rep> result = UString::Rep::create(a, 0, length);
658
659         a->checkConsistency();
660         b->checkConsistency();
661         result->checkConsistency();
662
663         return result;
664     }
665
666     if (-bOffset == bBase->usedPreCapacity && bSize >= minShareSize && 4 * bSize >= aSize) {
667         // - b reaches the beginning of its buffer so it qualifies for shared prepend
668         // - also, it's at least a quarter the length of a - prepending to a much shorter
669         //   string does more harm than good
670         UString y(b);
671         y.expandPreCapacity(-bOffset + aSize);
672         if (!b->data() || !y.data())
673             return 0;
674         copyChars(b->data() - aSize, a->data(), aSize);
675         PassRefPtr<UString::Rep> result = UString::Rep::create(b, -aSize, length);
676
677         a->checkConsistency();
678         b->checkConsistency();
679         result->checkConsistency();
680
681         return result;
682     }
683
684     // a does not qualify for append, and b does not qualify for prepend, gotta make a whole new string
685     size_t newCapacity = expandedSize(length, 0);
686     UChar* d = allocChars(newCapacity);
687     if (!d)
688         return 0;
689     copyChars(d, a->data(), aSize);
690     copyChars(d + aSize, b->data(), bSize);
691     PassRefPtr<UString::Rep> result = UString::Rep::create(d, length);
692     result->baseString()->capacity = newCapacity;
693
694     a->checkConsistency();
695     b->checkConsistency();
696     result->checkConsistency();
697
698     return result;
699 }
700
701 PassRefPtr<UString::Rep> concatenate(UString::Rep* rep, int i)
702 {
703     UChar buf[1 + sizeof(i) * 3];
704     UChar* end = buf + sizeof(buf) / sizeof(UChar);
705     UChar* p = end;
706   
707     if (i == 0)
708         *--p = '0';
709     else if (i == INT_MIN) {
710         char minBuf[1 + sizeof(i) * 3];
711         sprintf(minBuf, "%d", INT_MIN);
712         return concatenate(rep, minBuf);
713     } else {
714         bool negative = false;
715         if (i < 0) {
716             negative = true;
717             i = -i;
718         }
719         while (i) {
720             *--p = static_cast<unsigned short>((i % 10) + '0');
721             i /= 10;
722         }
723         if (negative)
724             *--p = '-';
725     }
726
727     return concatenate(rep, p, static_cast<int>(end - p));
728
729 }
730
731 PassRefPtr<UString::Rep> concatenate(UString::Rep* rep, double d)
732 {
733     // avoid ever printing -NaN, in JS conceptually there is only one NaN value
734     if (isnan(d))
735         return concatenate(rep, "NaN");
736
737     if (d == 0.0) // stringify -0 as 0
738         d = 0.0;
739
740     char buf[80];
741     int decimalPoint;
742     int sign;
743
744     char* result = WTF::dtoa(d, 0, &decimalPoint, &sign, NULL);
745     int length = static_cast<int>(strlen(result));
746   
747     int i = 0;
748     if (sign)
749         buf[i++] = '-';
750   
751     if (decimalPoint <= 0 && decimalPoint > -6) {
752         buf[i++] = '0';
753         buf[i++] = '.';
754         for (int j = decimalPoint; j < 0; j++)
755             buf[i++] = '0';
756         strcpy(buf + i, result);
757     } else if (decimalPoint <= 21 && decimalPoint > 0) {
758         if (length <= decimalPoint) {
759             strcpy(buf + i, result);
760             i += length;
761             for (int j = 0; j < decimalPoint - length; j++)
762                 buf[i++] = '0';
763             buf[i] = '\0';
764         } else {
765             strncpy(buf + i, result, decimalPoint);
766             i += decimalPoint;
767             buf[i++] = '.';
768             strcpy(buf + i, result + decimalPoint);
769         }
770     } else if (result[0] < '0' || result[0] > '9')
771         strcpy(buf + i, result);
772     else {
773         buf[i++] = result[0];
774         if (length > 1) {
775             buf[i++] = '.';
776             strcpy(buf + i, result + 1);
777             i += length - 1;
778         }
779         
780         buf[i++] = 'e';
781         buf[i++] = (decimalPoint >= 0) ? '+' : '-';
782         // decimalPoint can't be more than 3 digits decimal given the
783         // nature of float representation
784         int exponential = decimalPoint - 1;
785         if (exponential < 0)
786             exponential = -exponential;
787         if (exponential >= 100)
788             buf[i++] = static_cast<char>('0' + exponential / 100);
789         if (exponential >= 10)
790             buf[i++] = static_cast<char>('0' + (exponential % 100) / 10);
791         buf[i++] = static_cast<char>('0' + exponential % 10);
792         buf[i++] = '\0';
793     }
794     
795   WTF::freedtoa(result);
796
797   return concatenate(rep, buf);
798 }
799
800 UString UString::from(int i)
801 {
802     UChar buf[1 + sizeof(i) * 3];
803     UChar* end = buf + sizeof(buf) / sizeof(UChar);
804     UChar* p = end;
805   
806     if (i == 0)
807         *--p = '0';
808     else if (i == INT_MIN) {
809         char minBuf[1 + sizeof(i) * 3];
810         sprintf(minBuf, "%d", INT_MIN);
811         return UString(minBuf);
812     } else {
813         bool negative = false;
814         if (i < 0) {
815             negative = true;
816             i = -i;
817         }
818         while (i) {
819             *--p = static_cast<unsigned short>((i % 10) + '0');
820             i /= 10;
821         }
822         if (negative)
823             *--p = '-';
824     }
825
826     return UString(p, static_cast<int>(end - p));
827 }
828
829 UString UString::from(unsigned int u)
830 {
831     UChar buf[sizeof(u) * 3];
832     UChar* end = buf + sizeof(buf) / sizeof(UChar);
833     UChar* p = end;
834     
835     if (u == 0)
836         *--p = '0';
837     else {
838         while (u) {
839             *--p = static_cast<unsigned short>((u % 10) + '0');
840             u /= 10;
841         }
842     }
843     
844     return UString(p, static_cast<int>(end - p));
845 }
846
847 UString UString::from(long l)
848 {
849     UChar buf[1 + sizeof(l) * 3];
850     UChar* end = buf + sizeof(buf) / sizeof(UChar);
851     UChar* p = end;
852
853     if (l == 0)
854         *--p = '0';
855     else if (l == LONG_MIN) {
856         char minBuf[1 + sizeof(l) * 3];
857         sprintf(minBuf, "%ld", LONG_MIN);
858         return UString(minBuf);
859     } else {
860         bool negative = false;
861         if (l < 0) {
862             negative = true;
863             l = -l;
864         }
865         while (l) {
866             *--p = static_cast<unsigned short>((l % 10) + '0');
867             l /= 10;
868         }
869         if (negative)
870             *--p = '-';
871     }
872
873     return UString(p, static_cast<int>(end - p));
874 }
875
876 UString UString::from(double d)
877 {
878     // avoid ever printing -NaN, in JS conceptually there is only one NaN value
879     if (isnan(d))
880         return "NaN";
881
882     char buf[80];
883     int decimalPoint;
884     int sign;
885
886     char* result = WTF::dtoa(d, 0, &decimalPoint, &sign, NULL);
887     int length = static_cast<int>(strlen(result));
888   
889     int i = 0;
890     if (sign)
891         buf[i++] = '-';
892   
893     if (decimalPoint <= 0 && decimalPoint > -6) {
894         buf[i++] = '0';
895         buf[i++] = '.';
896         for (int j = decimalPoint; j < 0; j++)
897             buf[i++] = '0';
898         strcpy(buf + i, result);
899     } else if (decimalPoint <= 21 && decimalPoint > 0) {
900         if (length <= decimalPoint) {
901             strcpy(buf + i, result);
902             i += length;
903             for (int j = 0; j < decimalPoint - length; j++)
904                 buf[i++] = '0';
905             buf[i] = '\0';
906         } else {
907             strncpy(buf + i, result, decimalPoint);
908             i += decimalPoint;
909             buf[i++] = '.';
910             strcpy(buf + i, result + decimalPoint);
911         }
912     } else if (result[0] < '0' || result[0] > '9')
913         strcpy(buf + i, result);
914     else {
915         buf[i++] = result[0];
916         if (length > 1) {
917             buf[i++] = '.';
918             strcpy(buf + i, result + 1);
919             i += length - 1;
920         }
921         
922         buf[i++] = 'e';
923         buf[i++] = (decimalPoint >= 0) ? '+' : '-';
924         // decimalPoint can't be more than 3 digits decimal given the
925         // nature of float representation
926         int exponential = decimalPoint - 1;
927         if (exponential < 0)
928             exponential = -exponential;
929         if (exponential >= 100)
930             buf[i++] = static_cast<char>('0' + exponential / 100);
931         if (exponential >= 10)
932             buf[i++] = static_cast<char>('0' + (exponential % 100) / 10);
933         buf[i++] = static_cast<char>('0' + exponential % 10);
934         buf[i++] = '\0';
935     }
936     
937   WTF::freedtoa(result);
938
939   return UString(buf);
940 }
941
942 UString UString::spliceSubstringsWithSeparators(const Range* substringRanges, int rangeCount, const UString* separators, int separatorCount) const
943 {
944     m_rep->checkConsistency();
945
946     if (rangeCount == 1 && separatorCount == 0) {
947         int thisSize = size();
948         int position = substringRanges[0].position;
949         int length = substringRanges[0].length;
950         if (position <= 0 && length >= thisSize)
951             return *this;
952         return UString::Rep::create(m_rep, max(0, position), min(thisSize, length));
953     }
954
955     int totalLength = 0;
956     for (int i = 0; i < rangeCount; i++)
957         totalLength += substringRanges[i].length;
958     for (int i = 0; i < separatorCount; i++)
959         totalLength += separators[i].size();
960
961     if (totalLength == 0)
962         return "";
963
964     UChar* buffer = allocChars(totalLength);
965     if (!buffer)
966         return null();
967
968     int maxCount = max(rangeCount, separatorCount);
969     int bufferPos = 0;
970     for (int i = 0; i < maxCount; i++) {
971         if (i < rangeCount) {
972             copyChars(buffer + bufferPos, data() + substringRanges[i].position, substringRanges[i].length);
973             bufferPos += substringRanges[i].length;
974         }
975         if (i < separatorCount) {
976             copyChars(buffer + bufferPos, separators[i].data(), separators[i].size());
977             bufferPos += separators[i].size();
978         }
979     }
980
981     return UString::Rep::create(buffer, totalLength);
982 }
983
984 UString& UString::append(const UString &t)
985 {
986     m_rep->checkConsistency();
987     t.rep()->checkConsistency();
988
989     int thisSize = size();
990     int thisOffset = m_rep->offset;
991     int tSize = t.size();
992     int length = thisSize + tSize;
993     BaseString* base = m_rep->baseString();
994
995     // possible cases:
996     if (thisSize == 0) {
997         // this is empty
998         *this = t;
999     } else if (tSize == 0) {
1000         // t is empty
1001     } else if (m_rep == base && !base->isShared()) {
1002         // this is direct and has refcount of 1 (so we can just alter it directly)
1003         expandCapacity(newCapacityWithOverflowCheck(thisOffset, length));
1004         if (data()) {
1005             copyChars(m_rep->data() + thisSize, t.data(), tSize);
1006             m_rep->len = length;
1007             m_rep->_hash = 0;
1008         }
1009     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
1010         // this reaches the end of the buffer - extend it if it's long enough to append to
1011         expandCapacity(newCapacityWithOverflowCheck(thisOffset, length));
1012         if (data()) {
1013             copyChars(m_rep->data() + thisSize, t.data(), tSize);
1014             m_rep = Rep::create(m_rep, 0, length);
1015         }
1016     } else {
1017         // this is shared with someone using more capacity, gotta make a whole new string
1018         size_t newCapacity = expandedSize(length, 0);
1019         UChar* d = allocChars(newCapacity);
1020         if (!d)
1021             makeNull();
1022         else {
1023             copyChars(d, data(), thisSize);
1024             copyChars(d + thisSize, t.data(), tSize);
1025             m_rep = Rep::create(d, length);
1026             m_rep->baseString()->capacity = newCapacity;
1027         }
1028     }
1029
1030     m_rep->checkConsistency();
1031     t.rep()->checkConsistency();
1032
1033     return *this;
1034 }
1035
1036 UString& UString::append(const UChar* tData, int tSize)
1037 {
1038     m_rep = concatenate(m_rep.release(), tData, tSize);
1039     return *this;
1040 }
1041
1042 UString& UString::append(const char* t)
1043 {
1044     m_rep = concatenate(m_rep.release(), t);
1045     return *this;
1046 }
1047
1048 UString& UString::append(UChar c)
1049 {
1050     m_rep->checkConsistency();
1051
1052     int thisOffset = m_rep->offset;
1053     int length = size();
1054     BaseString* base = m_rep->baseString();
1055
1056     // possible cases:
1057     if (length == 0) {
1058         // this is empty - must make a new m_rep because we don't want to pollute the shared empty one 
1059         size_t newCapacity = expandedSize(1, 0);
1060         UChar* d = allocChars(newCapacity);
1061         if (!d)
1062             makeNull();
1063         else {
1064             d[0] = c;
1065             m_rep = Rep::create(d, 1);
1066             m_rep->baseString()->capacity = newCapacity;
1067         }
1068     } else if (m_rep == base && !base->isShared()) {
1069         // this is direct and has refcount of 1 (so we can just alter it directly)
1070         expandCapacity(newCapacityWithOverflowCheck(thisOffset, length, true));
1071         UChar* d = m_rep->data();
1072         if (d) {
1073             d[length] = c;
1074             m_rep->len = length + 1;
1075             m_rep->_hash = 0;
1076         }
1077     } else if (thisOffset + length == base->usedCapacity && length >= minShareSize) {
1078         // this reaches the end of the string - extend it and share
1079         expandCapacity(newCapacityWithOverflowCheck(thisOffset, length, true));
1080         UChar* d = m_rep->data();
1081         if (d) {
1082             d[length] = c;
1083             m_rep = Rep::create(m_rep, 0, length + 1);
1084         }
1085     } else {
1086         // this is shared with someone using more capacity, gotta make a whole new string
1087         size_t newCapacity = expandedSize(length + 1, 0);
1088         UChar* d = allocChars(newCapacity);
1089         if (!d)
1090             makeNull();
1091         else {
1092             copyChars(d, data(), length);
1093             d[length] = c;
1094             m_rep = Rep::create(d, length + 1);
1095             m_rep->baseString()->capacity = newCapacity;
1096         }
1097     }
1098
1099     m_rep->checkConsistency();
1100
1101     return *this;
1102 }
1103
1104 bool UString::getCString(CStringBuffer& buffer) const
1105 {
1106     int length = size();
1107     int neededSize = length + 1;
1108     buffer.resize(neededSize);
1109     char* buf = buffer.data();
1110
1111     UChar ored = 0;
1112     const UChar* p = data();
1113     char* q = buf;
1114     const UChar* limit = p + length;
1115     while (p != limit) {
1116         UChar c = p[0];
1117         ored |= c;
1118         *q = static_cast<char>(c);
1119         ++p;
1120         ++q;
1121     }
1122     *q = '\0';
1123
1124     return !(ored & 0xFF00);
1125 }
1126
1127 char* UString::ascii() const
1128 {
1129     int length = size();
1130     int neededSize = length + 1;
1131     delete[] statBuffer;
1132     statBuffer = new char[neededSize];
1133
1134     const UChar* p = data();
1135     char* q = statBuffer;
1136     const UChar* limit = p + length;
1137     while (p != limit) {
1138         *q = static_cast<char>(p[0]);
1139         ++p;
1140         ++q;
1141     }
1142     *q = '\0';
1143
1144     return statBuffer;
1145 }
1146
1147 UString& UString::operator=(const char* c)
1148 {
1149     if (!c) {
1150         m_rep = &Rep::null();
1151         return *this;
1152     }
1153
1154     if (!c[0]) {
1155         m_rep = &Rep::empty();
1156         return *this;
1157     }
1158
1159     int l = static_cast<int>(strlen(c));
1160     UChar* d;
1161     BaseString* base = m_rep->baseString();
1162     if (!base->isShared() && l <= base->capacity && m_rep == base && m_rep->offset == 0 && base->preCapacity == 0) {
1163         d = base->buf;
1164         m_rep->_hash = 0;
1165         m_rep->len = l;
1166     } else {
1167         d = allocChars(l);
1168         if (!d) {
1169             makeNull();
1170             return *this;
1171         }
1172         m_rep = Rep::create(d, l);
1173     }
1174     for (int i = 0; i < l; i++)
1175         d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
1176
1177     return *this;
1178 }
1179
1180 bool UString::is8Bit() const
1181 {
1182     const UChar* u = data();
1183     const UChar* limit = u + size();
1184     while (u < limit) {
1185         if (u[0] > 0xFF)
1186             return false;
1187         ++u;
1188     }
1189
1190     return true;
1191 }
1192
1193 UChar UString::operator[](int pos) const
1194 {
1195     if (pos >= size())
1196         return '\0';
1197     return data()[pos];
1198 }
1199
1200 double UString::toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const
1201 {
1202     if (size() == 1) {
1203         UChar c = data()[0];
1204         if (isASCIIDigit(c))
1205             return c - '0';
1206         if (isASCIISpace(c) && tolerateEmptyString)
1207             return 0;
1208         return NaN;
1209     }
1210
1211     // FIXME: If tolerateTrailingJunk is true, then we want to tolerate non-8-bit junk
1212     // after the number, so this is too strict a check.
1213     CStringBuffer s;
1214     if (!getCString(s))
1215         return NaN;
1216     const char* c = s.data();
1217
1218     // skip leading white space
1219     while (isASCIISpace(*c))
1220         c++;
1221
1222     // empty string ?
1223     if (*c == '\0')
1224         return tolerateEmptyString ? 0.0 : NaN;
1225
1226     double d;
1227
1228     // hex number ?
1229     if (*c == '0' && (*(c + 1) == 'x' || *(c + 1) == 'X')) {
1230         const char* firstDigitPosition = c + 2;
1231         c++;
1232         d = 0.0;
1233         while (*(++c)) {
1234             if (*c >= '0' && *c <= '9')
1235                 d = d * 16.0 + *c - '0';
1236             else if ((*c >= 'A' && *c <= 'F') || (*c >= 'a' && *c <= 'f'))
1237                 d = d * 16.0 + (*c & 0xdf) - 'A' + 10.0;
1238             else
1239                 break;
1240         }
1241
1242         if (d >= mantissaOverflowLowerBound)
1243             d = parseIntOverflow(firstDigitPosition, c - firstDigitPosition, 16);
1244     } else {
1245         // regular number ?
1246         char* end;
1247         d = WTF::strtod(c, &end);
1248         if ((d != 0.0 || end != c) && d != Inf && d != -Inf) {
1249             c = end;
1250         } else {
1251             double sign = 1.0;
1252
1253             if (*c == '+')
1254                 c++;
1255             else if (*c == '-') {
1256                 sign = -1.0;
1257                 c++;
1258             }
1259
1260             // We used strtod() to do the conversion. However, strtod() handles
1261             // infinite values slightly differently than JavaScript in that it
1262             // converts the string "inf" with any capitalization to infinity,
1263             // whereas the ECMA spec requires that it be converted to NaN.
1264
1265             if (c[0] == 'I' && c[1] == 'n' && c[2] == 'f' && c[3] == 'i' && c[4] == 'n' && c[5] == 'i' && c[6] == 't' && c[7] == 'y') {
1266                 d = sign * Inf;
1267                 c += 8;
1268             } else if ((d == Inf || d == -Inf) && *c != 'I' && *c != 'i')
1269                 c = end;
1270             else
1271                 return NaN;
1272         }
1273     }
1274
1275     // allow trailing white space
1276     while (isASCIISpace(*c))
1277         c++;
1278     // don't allow anything after - unless tolerant=true
1279     if (!tolerateTrailingJunk && *c != '\0')
1280         d = NaN;
1281
1282     return d;
1283 }
1284
1285 double UString::toDouble(bool tolerateTrailingJunk) const
1286 {
1287     return toDouble(tolerateTrailingJunk, true);
1288 }
1289
1290 double UString::toDouble() const
1291 {
1292     return toDouble(false, true);
1293 }
1294
1295 uint32_t UString::toUInt32(bool* ok) const
1296 {
1297     double d = toDouble();
1298     bool b = true;
1299
1300     if (d != static_cast<uint32_t>(d)) {
1301         b = false;
1302         d = 0;
1303     }
1304
1305     if (ok)
1306         *ok = b;
1307
1308     return static_cast<uint32_t>(d);
1309 }
1310
1311 uint32_t UString::toUInt32(bool* ok, bool tolerateEmptyString) const
1312 {
1313     double d = toDouble(false, tolerateEmptyString);
1314     bool b = true;
1315
1316     if (d != static_cast<uint32_t>(d)) {
1317         b = false;
1318         d = 0;
1319     }
1320
1321     if (ok)
1322         *ok = b;
1323
1324     return static_cast<uint32_t>(d);
1325 }
1326
1327 uint32_t UString::toStrictUInt32(bool* ok) const
1328 {
1329     if (ok)
1330         *ok = false;
1331
1332     // Empty string is not OK.
1333     int len = m_rep->len;
1334     if (len == 0)
1335         return 0;
1336     const UChar* p = m_rep->data();
1337     unsigned short c = p[0];
1338
1339     // If the first digit is 0, only 0 itself is OK.
1340     if (c == '0') {
1341         if (len == 1 && ok)
1342             *ok = true;
1343         return 0;
1344     }
1345
1346     // Convert to UInt32, checking for overflow.
1347     uint32_t i = 0;
1348     while (1) {
1349         // Process character, turning it into a digit.
1350         if (c < '0' || c > '9')
1351             return 0;
1352         const unsigned d = c - '0';
1353
1354         // Multiply by 10, checking for overflow out of 32 bits.
1355         if (i > 0xFFFFFFFFU / 10)
1356             return 0;
1357         i *= 10;
1358
1359         // Add in the digit, checking for overflow out of 32 bits.
1360         const unsigned max = 0xFFFFFFFFU - d;
1361         if (i > max)
1362             return 0;
1363         i += d;
1364
1365         // Handle end of string.
1366         if (--len == 0) {
1367             if (ok)
1368                 *ok = true;
1369             return i;
1370         }
1371
1372         // Get next character.
1373         c = *(++p);
1374     }
1375 }
1376
1377 int UString::find(const UString& f, int pos) const
1378 {
1379     int fsz = f.size();
1380
1381     if (pos < 0)
1382         pos = 0;
1383
1384     if (fsz == 1) {
1385         UChar ch = f[0];
1386         const UChar* end = data() + size();
1387         for (const UChar* c = data() + pos; c < end; c++) {
1388             if (*c == ch)
1389                 return static_cast<int>(c - data());
1390         }
1391         return -1;
1392     }
1393
1394     int sz = size();
1395     if (sz < fsz)
1396         return -1;
1397     if (fsz == 0)
1398         return pos;
1399     const UChar* end = data() + sz - fsz;
1400     int fsizeminusone = (fsz - 1) * sizeof(UChar);
1401     const UChar* fdata = f.data();
1402     unsigned short fchar = fdata[0];
1403     ++fdata;
1404     for (const UChar* c = data() + pos; c <= end; c++) {
1405         if (c[0] == fchar && !memcmp(c + 1, fdata, fsizeminusone))
1406             return static_cast<int>(c - data());
1407     }
1408
1409     return -1;
1410 }
1411
1412 int UString::find(UChar ch, int pos) const
1413 {
1414     if (pos < 0)
1415         pos = 0;
1416     const UChar* end = data() + size();
1417     for (const UChar* c = data() + pos; c < end; c++) {
1418         if (*c == ch)
1419             return static_cast<int>(c - data());
1420     }
1421     
1422     return -1;
1423 }
1424
1425 int UString::rfind(const UString& f, int pos) const
1426 {
1427     int sz = size();
1428     int fsz = f.size();
1429     if (sz < fsz)
1430         return -1;
1431     if (pos < 0)
1432         pos = 0;
1433     if (pos > sz - fsz)
1434         pos = sz - fsz;
1435     if (fsz == 0)
1436         return pos;
1437     int fsizeminusone = (fsz - 1) * sizeof(UChar);
1438     const UChar* fdata = f.data();
1439     for (const UChar* c = data() + pos; c >= data(); c--) {
1440         if (*c == *fdata && !memcmp(c + 1, fdata + 1, fsizeminusone))
1441             return static_cast<int>(c - data());
1442     }
1443
1444     return -1;
1445 }
1446
1447 int UString::rfind(UChar ch, int pos) const
1448 {
1449     if (isEmpty())
1450         return -1;
1451     if (pos + 1 >= size())
1452         pos = size() - 1;
1453     for (const UChar* c = data() + pos; c >= data(); c--) {
1454         if (*c == ch)
1455             return static_cast<int>(c - data());
1456     }
1457
1458     return -1;
1459 }
1460
1461 UString UString::substr(int pos, int len) const
1462 {
1463     int s = size();
1464
1465     if (pos < 0)
1466         pos = 0;
1467     else if (pos >= s)
1468         pos = s;
1469     if (len < 0)
1470         len = s;
1471     if (pos + len >= s)
1472         len = s - pos;
1473
1474     if (pos == 0 && len == s)
1475         return *this;
1476
1477     return UString(Rep::create(m_rep, pos, len));
1478 }
1479
1480 bool operator==(const UString& s1, const UString& s2)
1481 {
1482     int size = s1.size();
1483     switch (size) {
1484         case 0:
1485             return !s2.size();
1486         case 1:
1487             return s2.size() == 1 && s1.data()[0] == s2.data()[0];
1488         default:
1489             return s2.size() == size && memcmp(s1.data(), s2.data(), size * sizeof(UChar)) == 0;
1490     }
1491 }
1492
1493 bool operator==(const UString& s1, const char *s2)
1494 {
1495     if (s2 == 0)
1496         return s1.isEmpty();
1497
1498     const UChar* u = s1.data();
1499     const UChar* uend = u + s1.size();
1500     while (u != uend && *s2) {
1501         if (u[0] != (unsigned char)*s2)
1502             return false;
1503         s2++;
1504         u++;
1505     }
1506
1507     return u == uend && *s2 == 0;
1508 }
1509
1510 bool operator<(const UString& s1, const UString& s2)
1511 {
1512     const int l1 = s1.size();
1513     const int l2 = s2.size();
1514     const int lmin = l1 < l2 ? l1 : l2;
1515     const UChar* c1 = s1.data();
1516     const UChar* c2 = s2.data();
1517     int l = 0;
1518     while (l < lmin && *c1 == *c2) {
1519         c1++;
1520         c2++;
1521         l++;
1522     }
1523     if (l < lmin)
1524         return (c1[0] < c2[0]);
1525
1526     return (l1 < l2);
1527 }
1528
1529 bool operator>(const UString& s1, const UString& s2)
1530 {
1531     const int l1 = s1.size();
1532     const int l2 = s2.size();
1533     const int lmin = l1 < l2 ? l1 : l2;
1534     const UChar* c1 = s1.data();
1535     const UChar* c2 = s2.data();
1536     int l = 0;
1537     while (l < lmin && *c1 == *c2) {
1538         c1++;
1539         c2++;
1540         l++;
1541     }
1542     if (l < lmin)
1543         return (c1[0] > c2[0]);
1544
1545     return (l1 > l2);
1546 }
1547
1548 int compare(const UString& s1, const UString& s2)
1549 {
1550     const int l1 = s1.size();
1551     const int l2 = s2.size();
1552     const int lmin = l1 < l2 ? l1 : l2;
1553     const UChar* c1 = s1.data();
1554     const UChar* c2 = s2.data();
1555     int l = 0;
1556     while (l < lmin && *c1 == *c2) {
1557         c1++;
1558         c2++;
1559         l++;
1560     }
1561
1562     if (l < lmin)
1563         return (c1[0] > c2[0]) ? 1 : -1;
1564
1565     if (l1 == l2)
1566         return 0;
1567
1568     return (l1 > l2) ? 1 : -1;
1569 }
1570
1571 bool equal(const UString::Rep* r, const UString::Rep* b)
1572 {
1573     int length = r->len;
1574     if (length != b->len)
1575         return false;
1576     const UChar* d = r->data();
1577     const UChar* s = b->data();
1578     for (int i = 0; i != length; ++i) {
1579         if (d[i] != s[i])
1580             return false;
1581     }
1582     return true;
1583 }
1584
1585 CString UString::UTF8String(bool strict) const
1586 {
1587     // Allocate a buffer big enough to hold all the characters.
1588     const int length = size();
1589     Vector<char, 1024> buffer(length * 3);
1590
1591     // Convert to runs of 8-bit characters.
1592     char* p = buffer.data();
1593     const UChar* d = reinterpret_cast<const UChar*>(&data()[0]);
1594     ConversionResult result = convertUTF16ToUTF8(&d, d + length, &p, p + buffer.size(), strict);
1595     if (result != conversionOK)
1596         return CString();
1597
1598     return CString(buffer.data(), p - buffer.data());
1599 }
1600
1601 // For use in error handling code paths -- having this not be inlined helps avoid PIC branches to fetch the global on Mac OS X.
1602 NEVER_INLINE void UString::makeNull()
1603 {
1604     m_rep = &Rep::null();
1605 }
1606
1607 // For use in error handling code paths -- having this not be inlined helps avoid PIC branches to fetch the global on Mac OS X.
1608 NEVER_INLINE UString::Rep* UString::nullRep()
1609 {
1610     return &Rep::null();
1611 }
1612
1613 } // namespace JSC