String::append() should handle two 8 bit strings without converting both to 16 bits
[WebKit-https.git] / Source / WTF / wtf / text / WTFString.cpp
1 /*
2  * (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
4  * Copyright (C) 2007-2009 Torch Mobile, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library 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  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "WTFString.h"
24
25 #include "IntegerToStringConversion.h"
26 #include <stdarg.h>
27 #include <wtf/ASCIICType.h>
28 #include <wtf/DataLog.h>
29 #include <wtf/HexNumber.h>
30 #include <wtf/MathExtras.h>
31 #include <wtf/text/CString.h>
32 #include <wtf/StringExtras.h>
33 #include <wtf/Vector.h>
34 #include <wtf/dtoa.h>
35 #include <wtf/unicode/CharacterNames.h>
36 #include <wtf/unicode/UTF8.h>
37 #include <wtf/unicode/Unicode.h>
38
39 using namespace std;
40
41 namespace WTF {
42
43 using namespace Unicode;
44 using namespace std;
45
46 // Construct a string with UTF-16 data.
47 String::String(const UChar* characters, unsigned length)
48     : m_impl(characters ? StringImpl::create(characters, length) : 0)
49 {
50 }
51
52 // Construct a string with UTF-16 data, from a null-terminated source.
53 String::String(const UChar* str)
54 {
55     if (!str)
56         return;
57         
58     size_t len = 0;
59     while (str[len] != UChar(0))
60         ++len;
61
62     if (len > numeric_limits<unsigned>::max())
63         CRASH();
64     
65     m_impl = StringImpl::create(str, len);
66 }
67
68 // Construct a string with latin1 data.
69 String::String(const LChar* characters, unsigned length)
70     : m_impl(characters ? StringImpl::create(characters, length) : 0)
71 {
72 }
73
74 String::String(const char* characters, unsigned length)
75     : m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters), length) : 0)
76 {
77 }
78
79 // Construct a string with latin1 data, from a null-terminated source.
80 String::String(const LChar* characters)
81     : m_impl(characters ? StringImpl::create(characters) : 0)
82 {
83 }
84
85 String::String(const char* characters)
86     : m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters)) : 0)
87 {
88 }
89
90 String::String(ASCIILiteral characters)
91     : m_impl(StringImpl::createFromLiteral(characters))
92 {
93 }
94
95 void String::append(const String& str)
96 {
97     if (str.isEmpty())
98        return;
99
100     // FIXME: This is extremely inefficient. So much so that we might want to take this
101     // out of String's API. We can make it better by optimizing the case where exactly
102     // one String is pointing at this StringImpl, but even then it's going to require a
103     // call to fastMalloc every single time.
104     if (str.m_impl) {
105         if (m_impl) {
106             if (m_impl->is8Bit() && str.m_impl->is8Bit()) {
107                 LChar* data;
108                 if (str.length() > numeric_limits<unsigned>::max() - m_impl->length())
109                     CRASH();
110                 RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + str.length(), data);
111                 memcpy(data, m_impl->characters8(), m_impl->length() * sizeof(LChar));
112                 memcpy(data + m_impl->length(), str.characters8(), str.length() * sizeof(LChar));
113                 m_impl = newImpl.release();
114                 return;
115             }
116             UChar* data;
117             if (str.length() > numeric_limits<unsigned>::max() - m_impl->length())
118                 CRASH();
119             RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + str.length(), data);
120             memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar));
121             memcpy(data + m_impl->length(), str.characters(), str.length() * sizeof(UChar));
122             m_impl = newImpl.release();
123         } else
124             m_impl = str.m_impl;
125     }
126 }
127
128 void String::append(LChar c)
129 {
130     // FIXME: This is extremely inefficient. So much so that we might want to take this
131     // out of String's API. We can make it better by optimizing the case where exactly
132     // one String is pointing at this StringImpl, but even then it's going to require a
133     // call to fastMalloc every single time.
134     if (m_impl) {
135         UChar* data;
136         if (m_impl->length() >= numeric_limits<unsigned>::max())
137             CRASH();
138         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data);
139         memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar));
140         data[m_impl->length()] = c;
141         m_impl = newImpl.release();
142     } else
143         m_impl = StringImpl::create(&c, 1);
144 }
145
146 void String::append(UChar c)
147 {
148     // FIXME: This is extremely inefficient. So much so that we might want to take this
149     // out of String's API. We can make it better by optimizing the case where exactly
150     // one String is pointing at this StringImpl, but even then it's going to require a
151     // call to fastMalloc every single time.
152     if (m_impl) {
153         UChar* data;
154         if (m_impl->length() >= numeric_limits<unsigned>::max())
155             CRASH();
156         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data);
157         memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar));
158         data[m_impl->length()] = c;
159         m_impl = newImpl.release();
160     } else
161         m_impl = StringImpl::create(&c, 1);
162 }
163
164 int codePointCompare(const String& a, const String& b)
165 {
166     return codePointCompare(a.impl(), b.impl());
167 }
168
169 void String::insert(const String& str, unsigned pos)
170 {
171     if (str.isEmpty()) {
172         if (str.isNull())
173             return;
174         if (isNull())
175             m_impl = str.impl();
176         return;
177     }
178     insert(str.characters(), str.length(), pos);
179 }
180
181 void String::append(const LChar* charactersToAppend, unsigned lengthToAppend)
182 {
183     if (!m_impl) {
184         if (!charactersToAppend)
185             return;
186         m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
187         return;
188     }
189
190     if (!lengthToAppend)
191         return;
192
193     ASSERT(charactersToAppend);
194
195     unsigned strLength = m_impl->length();
196
197     if (m_impl->is8Bit()) {
198         if (lengthToAppend > numeric_limits<unsigned>::max() - strLength)
199             CRASH();
200         LChar* data;
201         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
202         StringImpl::copyChars(data, m_impl->characters8(), strLength);
203         StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
204         m_impl = newImpl.release();
205         return;
206     }
207
208     if (lengthToAppend > numeric_limits<unsigned>::max() - strLength)
209         CRASH();
210     UChar* data;
211     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data);
212     StringImpl::copyChars(data, m_impl->characters16(), strLength);
213     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
214     m_impl = newImpl.release();
215 }
216
217 void String::append(const UChar* charactersToAppend, unsigned lengthToAppend)
218 {
219     if (!m_impl) {
220         if (!charactersToAppend)
221             return;
222         m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
223         return;
224     }
225
226     if (!lengthToAppend)
227         return;
228
229     unsigned strLength = m_impl->length();
230     
231     ASSERT(charactersToAppend);
232     if (lengthToAppend > numeric_limits<unsigned>::max() - strLength)
233         CRASH();
234     UChar* data;
235     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
236     if (m_impl->is8Bit())
237         StringImpl::copyChars(data, characters8(), strLength);
238     else
239         StringImpl::copyChars(data, characters16(), strLength);
240     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
241     m_impl = newImpl.release();
242 }
243
244
245 void String::insert(const UChar* charactersToInsert, unsigned lengthToInsert, unsigned position)
246 {
247     if (position >= length()) {
248         append(charactersToInsert, lengthToInsert);
249         return;
250     }
251
252     ASSERT(m_impl);
253
254     if (!lengthToInsert)
255         return;
256
257     ASSERT(charactersToInsert);
258     UChar* data;
259     if (lengthToInsert > numeric_limits<unsigned>::max() - length())
260         CRASH();
261     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToInsert, data);
262     memcpy(data, characters(), position * sizeof(UChar));
263     memcpy(data + position, charactersToInsert, lengthToInsert * sizeof(UChar));
264     memcpy(data + position + lengthToInsert, characters() + position, (length() - position) * sizeof(UChar));
265     m_impl = newImpl.release();
266 }
267
268 UChar32 String::characterStartingAt(unsigned i) const
269 {
270     if (!m_impl || i >= m_impl->length())
271         return 0;
272     return m_impl->characterStartingAt(i);
273 }
274
275 void String::truncate(unsigned position)
276 {
277     if (position >= length())
278         return;
279     UChar* data;
280     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(position, data);
281     memcpy(data, characters(), position * sizeof(UChar));
282     m_impl = newImpl.release();
283 }
284
285 template <typename CharacterType>
286 inline void String::removeInternal(const CharacterType* characters, unsigned position, int lengthToRemove)
287 {
288     CharacterType* data;
289     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() - lengthToRemove, data);
290     memcpy(data, characters, position * sizeof(CharacterType));
291     memcpy(data + position, characters + position + lengthToRemove,
292         (length() - lengthToRemove - position) * sizeof(CharacterType));
293
294     m_impl = newImpl.release();
295 }
296
297 void String::remove(unsigned position, int lengthToRemove)
298 {
299     if (lengthToRemove <= 0)
300         return;
301     if (position >= length())
302         return;
303     if (static_cast<unsigned>(lengthToRemove) > length() - position)
304         lengthToRemove = length() - position;
305
306     if (is8Bit()) {
307         removeInternal(characters8(), position, lengthToRemove);
308
309         return;
310     }
311
312     removeInternal(characters16(), position, lengthToRemove);
313 }
314
315 String String::substring(unsigned pos, unsigned len) const
316 {
317     if (!m_impl) 
318         return String();
319     return m_impl->substring(pos, len);
320 }
321
322 String String::substringSharingImpl(unsigned offset, unsigned length) const
323 {
324     // FIXME: We used to check against a limit of Heap::minExtraCost / sizeof(UChar).
325
326     unsigned stringLength = this->length();
327     offset = min(offset, stringLength);
328     length = min(length, stringLength - offset);
329
330     if (!offset && length == stringLength)
331         return *this;
332     return String(StringImpl::create(m_impl, offset, length));
333 }
334
335 String String::lower() const
336 {
337     if (!m_impl)
338         return String();
339     return m_impl->lower();
340 }
341
342 String String::upper() const
343 {
344     if (!m_impl)
345         return String();
346     return m_impl->upper();
347 }
348
349 String String::stripWhiteSpace() const
350 {
351     if (!m_impl)
352         return String();
353     return m_impl->stripWhiteSpace();
354 }
355
356 String String::stripWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
357 {
358     if (!m_impl)
359         return String();
360     return m_impl->stripWhiteSpace(isWhiteSpace);
361 }
362
363 String String::simplifyWhiteSpace() const
364 {
365     if (!m_impl)
366         return String();
367     return m_impl->simplifyWhiteSpace();
368 }
369
370 String String::simplifyWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
371 {
372     if (!m_impl)
373         return String();
374     return m_impl->simplifyWhiteSpace(isWhiteSpace);
375 }
376
377 String String::removeCharacters(CharacterMatchFunctionPtr findMatch) const
378 {
379     if (!m_impl)
380         return String();
381     return m_impl->removeCharacters(findMatch);
382 }
383
384 String String::foldCase() const
385 {
386     if (!m_impl)
387         return String();
388     return m_impl->foldCase();
389 }
390
391 bool String::percentage(int& result) const
392 {
393     if (!m_impl || !m_impl->length())
394         return false;
395
396     if ((*m_impl)[m_impl->length() - 1] != '%')
397        return false;
398
399     result = charactersToIntStrict(m_impl->characters(), m_impl->length() - 1);
400     return true;
401 }
402
403 const UChar* String::charactersWithNullTermination()
404 {
405     if (!m_impl)
406         return 0;
407     if (m_impl->hasTerminatingNullCharacter())
408         return m_impl->characters();
409     m_impl = StringImpl::createWithTerminatingNullCharacter(*m_impl);
410     return m_impl->characters();
411 }
412
413 String String::format(const char *format, ...)
414 {
415 #if PLATFORM(QT)
416     // Use QString::vsprintf to avoid the locale dependent formatting of vsnprintf.
417     // https://bugs.webkit.org/show_bug.cgi?id=18994
418     va_list args;
419     va_start(args, format);
420
421     QString buffer;
422     buffer.vsprintf(format, args);
423
424     va_end(args);
425
426     QByteArray ba = buffer.toUtf8();
427     return StringImpl::create(reinterpret_cast<const LChar*>(ba.constData()), ba.length());
428
429 #elif OS(WINCE)
430     va_list args;
431     va_start(args, format);
432
433     Vector<char, 256> buffer;
434
435     int bufferSize = 256;
436     buffer.resize(bufferSize);
437     for (;;) {
438         int written = vsnprintf(buffer.data(), bufferSize, format, args);
439         va_end(args);
440
441         if (written == 0)
442             return String("");
443         if (written > 0)
444             return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), written);
445         
446         bufferSize <<= 1;
447         buffer.resize(bufferSize);
448         va_start(args, format);
449     }
450
451 #else
452     va_list args;
453     va_start(args, format);
454
455     Vector<char, 256> buffer;
456
457     // Do the format once to get the length.
458 #if COMPILER(MSVC)
459     int result = _vscprintf(format, args);
460 #else
461     char ch;
462     int result = vsnprintf(&ch, 1, format, args);
463     // We need to call va_end() and then va_start() again here, as the
464     // contents of args is undefined after the call to vsnprintf
465     // according to http://man.cx/snprintf(3)
466     //
467     // Not calling va_end/va_start here happens to work on lots of
468     // systems, but fails e.g. on 64bit Linux.
469     va_end(args);
470     va_start(args, format);
471 #endif
472
473     if (result == 0)
474         return String("");
475     if (result < 0)
476         return String();
477     unsigned len = result;
478     buffer.grow(len + 1);
479     
480     // Now do the formatting again, guaranteed to fit.
481     vsnprintf(buffer.data(), buffer.size(), format, args);
482
483     va_end(args);
484     
485     return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), len);
486 #endif
487 }
488
489 String String::number(int number)
490 {
491     return numberToStringSigned<String>(number);
492 }
493
494 String String::number(unsigned int number)
495 {
496     return numberToStringUnsigned<String>(number);
497 }
498
499 String String::number(long number)
500 {
501     return numberToStringSigned<String>(number);
502 }
503
504 String String::number(unsigned long number)
505 {
506     return numberToStringUnsigned<String>(number);
507 }
508
509 String String::number(long long number)
510 {
511     return numberToStringSigned<String>(number);
512 }
513
514 String String::number(unsigned long long number)
515 {
516     return numberToStringUnsigned<String>(number);
517 }
518
519 String String::number(double number, unsigned precision, TrailingZerosTruncatingPolicy trailingZerosTruncatingPolicy)
520 {
521     NumberToStringBuffer buffer;
522     return String(numberToFixedPrecisionString(number, precision, buffer, trailingZerosTruncatingPolicy == TruncateTrailingZeros));
523 }
524
525 String String::numberToStringECMAScript(double number)
526 {
527     NumberToStringBuffer buffer;
528     return String(numberToString(number, buffer));
529 }
530
531 String String::numberToStringFixedWidth(double number, unsigned decimalPlaces)
532 {
533     NumberToStringBuffer buffer;
534     return String(numberToFixedWidthString(number, decimalPlaces, buffer));
535 }
536
537 int String::toIntStrict(bool* ok, int base) const
538 {
539     if (!m_impl) {
540         if (ok)
541             *ok = false;
542         return 0;
543     }
544     return m_impl->toIntStrict(ok, base);
545 }
546
547 unsigned String::toUIntStrict(bool* ok, int base) const
548 {
549     if (!m_impl) {
550         if (ok)
551             *ok = false;
552         return 0;
553     }
554     return m_impl->toUIntStrict(ok, base);
555 }
556
557 int64_t String::toInt64Strict(bool* ok, int base) const
558 {
559     if (!m_impl) {
560         if (ok)
561             *ok = false;
562         return 0;
563     }
564     return m_impl->toInt64Strict(ok, base);
565 }
566
567 uint64_t String::toUInt64Strict(bool* ok, int base) const
568 {
569     if (!m_impl) {
570         if (ok)
571             *ok = false;
572         return 0;
573     }
574     return m_impl->toUInt64Strict(ok, base);
575 }
576
577 intptr_t String::toIntPtrStrict(bool* ok, int base) const
578 {
579     if (!m_impl) {
580         if (ok)
581             *ok = false;
582         return 0;
583     }
584     return m_impl->toIntPtrStrict(ok, base);
585 }
586
587 int String::toInt(bool* ok) const
588 {
589     if (!m_impl) {
590         if (ok)
591             *ok = false;
592         return 0;
593     }
594     return m_impl->toInt(ok);
595 }
596
597 unsigned String::toUInt(bool* ok) const
598 {
599     if (!m_impl) {
600         if (ok)
601             *ok = false;
602         return 0;
603     }
604     return m_impl->toUInt(ok);
605 }
606
607 int64_t String::toInt64(bool* ok) const
608 {
609     if (!m_impl) {
610         if (ok)
611             *ok = false;
612         return 0;
613     }
614     return m_impl->toInt64(ok);
615 }
616
617 uint64_t String::toUInt64(bool* ok) const
618 {
619     if (!m_impl) {
620         if (ok)
621             *ok = false;
622         return 0;
623     }
624     return m_impl->toUInt64(ok);
625 }
626
627 intptr_t String::toIntPtr(bool* ok) const
628 {
629     if (!m_impl) {
630         if (ok)
631             *ok = false;
632         return 0;
633     }
634     return m_impl->toIntPtr(ok);
635 }
636
637 double String::toDouble(bool* ok) const
638 {
639     if (!m_impl) {
640         if (ok)
641             *ok = false;
642         return 0.0;
643     }
644     return m_impl->toDouble(ok);
645 }
646
647 float String::toFloat(bool* ok) const
648 {
649     if (!m_impl) {
650         if (ok)
651             *ok = false;
652         return 0.0f;
653     }
654     return m_impl->toFloat(ok);
655 }
656
657 String String::isolatedCopy() const
658 {
659     if (!m_impl)
660         return String();
661     return m_impl->isolatedCopy();
662 }
663
664 void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const
665 {
666     result.clear();
667
668     unsigned startPos = 0;
669     size_t endPos;
670     while ((endPos = find(separator, startPos)) != notFound) {
671         if (allowEmptyEntries || startPos != endPos)
672             result.append(substring(startPos, endPos - startPos));
673         startPos = endPos + separator.length();
674     }
675     if (allowEmptyEntries || startPos != length())
676         result.append(substring(startPos));
677 }
678
679 void String::split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const
680 {
681     result.clear();
682
683     unsigned startPos = 0;
684     size_t endPos;
685     while ((endPos = find(separator, startPos)) != notFound) {
686         if (allowEmptyEntries || startPos != endPos)
687             result.append(substring(startPos, endPos - startPos));
688         startPos = endPos + 1;
689     }
690     if (allowEmptyEntries || startPos != length())
691         result.append(substring(startPos));
692 }
693
694 CString String::ascii() const
695 {
696     // Printable ASCII characters 32..127 and the null character are
697     // preserved, characters outside of this range are converted to '?'.
698
699     unsigned length = this->length();
700     if (!length) { 
701         char* characterBuffer;
702         return CString::newUninitialized(length, characterBuffer);
703     }
704
705     if (this->is8Bit()) {
706         const LChar* characters = this->characters8();
707
708         char* characterBuffer;
709         CString result = CString::newUninitialized(length, characterBuffer);
710
711         for (unsigned i = 0; i < length; ++i) {
712             LChar ch = characters[i];
713             characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
714         }
715
716         return result;        
717     }
718
719     const UChar* characters = this->characters16();
720
721     char* characterBuffer;
722     CString result = CString::newUninitialized(length, characterBuffer);
723
724     for (unsigned i = 0; i < length; ++i) {
725         UChar ch = characters[i];
726         characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
727     }
728
729     return result;
730 }
731
732 CString String::latin1() const
733 {
734     // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are
735     // preserved, characters outside of this range are converted to '?'.
736
737     unsigned length = this->length();
738
739     if (!length)
740         return CString("", 0);
741
742     if (is8Bit())
743         return CString(reinterpret_cast<const char*>(this->characters8()), length);
744
745     const UChar* characters = this->characters16();
746
747     char* characterBuffer;
748     CString result = CString::newUninitialized(length, characterBuffer);
749
750     for (unsigned i = 0; i < length; ++i) {
751         UChar ch = characters[i];
752         characterBuffer[i] = ch > 0xff ? '?' : ch;
753     }
754
755     return result;
756 }
757
758 // Helper to write a three-byte UTF-8 code point to the buffer, caller must check room is available.
759 static inline void putUTF8Triple(char*& buffer, UChar ch)
760 {
761     ASSERT(ch >= 0x0800);
762     *buffer++ = static_cast<char>(((ch >> 12) & 0x0F) | 0xE0);
763     *buffer++ = static_cast<char>(((ch >> 6) & 0x3F) | 0x80);
764     *buffer++ = static_cast<char>((ch & 0x3F) | 0x80);
765 }
766
767 CString String::utf8(ConversionMode mode) const
768 {
769     unsigned length = this->length();
770
771     if (!length)
772         return CString("", 0);
773
774     // Allocate a buffer big enough to hold all the characters
775     // (an individual UTF-16 UChar can only expand to 3 UTF-8 bytes).
776     // Optimization ideas, if we find this function is hot:
777     //  * We could speculatively create a CStringBuffer to contain 'length' 
778     //    characters, and resize if necessary (i.e. if the buffer contains
779     //    non-ascii characters). (Alternatively, scan the buffer first for
780     //    ascii characters, so we know this will be sufficient).
781     //  * We could allocate a CStringBuffer with an appropriate size to
782     //    have a good chance of being able to write the string into the
783     //    buffer without reallocing (say, 1.5 x length).
784     if (length > numeric_limits<unsigned>::max() / 3)
785         return CString();
786     Vector<char, 1024> bufferVector(length * 3);
787
788     char* buffer = bufferVector.data();
789
790     if (is8Bit()) {
791         const LChar* characters = this->characters8();
792
793         ConversionResult result = convertLatin1ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size());
794         ASSERT_UNUSED(result, result != targetExhausted); // (length * 3) should be sufficient for any conversion
795     } else {
796         const UChar* characters = this->characters16();
797
798         if (mode == StrictConversionReplacingUnpairedSurrogatesWithFFFD) {
799             const UChar* charactersEnd = characters + length;
800             char* bufferEnd = buffer + bufferVector.size();
801             while (characters < charactersEnd) {
802                 // Use strict conversion to detect unpaired surrogates.
803                 ConversionResult result = convertUTF16ToUTF8(&characters, charactersEnd, &buffer, bufferEnd, true);
804                 ASSERT(result != targetExhausted);
805                 // Conversion fails when there is an unpaired surrogate.
806                 // Put replacement character (U+FFFD) instead of the unpaired surrogate.
807                 if (result != conversionOK) {
808                     ASSERT((0xD800 <= *characters && *characters <= 0xDFFF));
809                     // There should be room left, since one UChar hasn't been converted.
810                     ASSERT((buffer + 3) <= bufferEnd);
811                     putUTF8Triple(buffer, replacementCharacter);
812                     ++characters;
813                 }
814             }
815         } else {
816             bool strict = mode == StrictConversion;
817             ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict);
818             ASSERT(result != targetExhausted); // (length * 3) should be sufficient for any conversion
819
820             // Only produced from strict conversion.
821             if (result == sourceIllegal) {
822                 ASSERT(strict);
823                 return CString();
824             }
825
826             // Check for an unconverted high surrogate.
827             if (result == sourceExhausted) {
828                 if (strict)
829                     return CString();
830                 // This should be one unpaired high surrogate. Treat it the same
831                 // was as an unpaired high surrogate would have been handled in
832                 // the middle of a string with non-strict conversion - which is
833                 // to say, simply encode it to UTF-8.
834                 ASSERT((characters + 1) == (this->characters() + length));
835                 ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF));
836                 // There should be room left, since one UChar hasn't been converted.
837                 ASSERT((buffer + 3) <= (buffer + bufferVector.size()));
838                 putUTF8Triple(buffer, *characters);
839             }
840         }
841     }
842
843     return CString(bufferVector.data(), buffer - bufferVector.data());
844 }
845
846 String String::make8BitFrom16BitSource(const UChar* source, size_t length)
847 {
848     if (!length)
849         return String();
850
851     LChar* destination;
852     String result = String::createUninitialized(length, destination);
853
854     copyLCharsFromUCharSource(destination, source, length);
855
856     return result;
857 }
858
859 String String::make16BitFrom8BitSource(const LChar* source, size_t length)
860 {
861     if (!length)
862         return String();
863     
864     UChar* destination;
865     String result = String::createUninitialized(length, destination);
866     
867     StringImpl::copyChars(destination, source, length);
868     
869     return result;
870 }
871
872 String String::fromUTF8(const LChar* stringStart, size_t length)
873 {
874     if (length > numeric_limits<unsigned>::max())
875         CRASH();
876
877     if (!stringStart)
878         return String();
879
880     // We'll use a StringImpl as a buffer; if the source string only contains ascii this should be
881     // the right length, if there are any multi-byte sequences this buffer will be too large.
882     UChar* buffer;
883     String stringBuffer(StringImpl::createUninitialized(length, buffer));
884     UChar* bufferEnd = buffer + length;
885
886     // Try converting into the buffer.
887     const char* stringCurrent = reinterpret_cast<const char*>(stringStart);
888     if (convertUTF8ToUTF16(&stringCurrent, reinterpret_cast<const char *>(stringStart + length), &buffer, bufferEnd) != conversionOK)
889         return String();
890
891     // stringBuffer is full (the input must have been all ascii) so just return it!
892     if (buffer == bufferEnd)
893         return stringBuffer;
894
895     // stringBuffer served its purpose as a buffer, copy the contents out into a new string.
896     unsigned utf16Length = buffer - stringBuffer.characters();
897     ASSERT(utf16Length < length);
898     return String(stringBuffer.characters(), utf16Length);
899 }
900
901 String String::fromUTF8(const LChar* string)
902 {
903     if (!string)
904         return String();
905     return fromUTF8(string, strlen(reinterpret_cast<const char*>(string)));
906 }
907
908 String String::fromUTF8WithLatin1Fallback(const LChar* string, size_t size)
909 {
910     String utf8 = fromUTF8(string, size);
911     if (!utf8)
912         return String(string, size);
913     return utf8;
914 }
915
916 // String Operations
917
918 static bool isCharacterAllowedInBase(UChar c, int base)
919 {
920     if (c > 0x7F)
921         return false;
922     if (isASCIIDigit(c))
923         return c - '0' < base;
924     if (isASCIIAlpha(c)) {
925         if (base > 36)
926             base = 36;
927         return (c >= 'a' && c < 'a' + base - 10)
928             || (c >= 'A' && c < 'A' + base - 10);
929     }
930     return false;
931 }
932
933 template <typename IntegralType, typename CharType>
934 static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
935 {
936     static const IntegralType integralMax = numeric_limits<IntegralType>::max();
937     static const bool isSigned = numeric_limits<IntegralType>::is_signed;
938     const IntegralType maxMultiplier = integralMax / base;
939
940     IntegralType value = 0;
941     bool isOk = false;
942     bool isNegative = false;
943
944     if (!data)
945         goto bye;
946
947     // skip leading whitespace
948     while (length && isSpaceOrNewline(*data)) {
949         --length;
950         ++data;
951     }
952
953     if (isSigned && length && *data == '-') {
954         --length;
955         ++data;
956         isNegative = true;
957     } else if (length && *data == '+') {
958         --length;
959         ++data;
960     }
961
962     if (!length || !isCharacterAllowedInBase(*data, base))
963         goto bye;
964
965     while (length && isCharacterAllowedInBase(*data, base)) {
966         --length;
967         IntegralType digitValue;
968         CharType c = *data;
969         if (isASCIIDigit(c))
970             digitValue = c - '0';
971         else if (c >= 'a')
972             digitValue = c - 'a' + 10;
973         else
974             digitValue = c - 'A' + 10;
975
976         if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative))
977             goto bye;
978
979         value = base * value + digitValue;
980         ++data;
981     }
982
983 #if COMPILER(MSVC)
984 #pragma warning(push, 0)
985 #pragma warning(disable:4146)
986 #endif
987
988     if (isNegative)
989         value = -value;
990
991 #if COMPILER(MSVC)
992 #pragma warning(pop)
993 #endif
994
995     // skip trailing space
996     while (length && isSpaceOrNewline(*data)) {
997         --length;
998         ++data;
999     }
1000
1001     if (!length)
1002         isOk = true;
1003 bye:
1004     if (ok)
1005         *ok = isOk;
1006     return isOk ? value : 0;
1007 }
1008
1009 template <typename CharType>
1010 static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length)
1011 {
1012     size_t i = 0;
1013
1014     // Allow leading spaces.
1015     for (; i != length; ++i) {
1016         if (!isSpaceOrNewline(data[i]))
1017             break;
1018     }
1019     
1020     // Allow sign.
1021     if (i != length && (data[i] == '+' || data[i] == '-'))
1022         ++i;
1023     
1024     // Allow digits.
1025     for (; i != length; ++i) {
1026         if (!isASCIIDigit(data[i]))
1027             break;
1028     }
1029
1030     return i;
1031 }
1032
1033 int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base)
1034 {
1035     return toIntegralType<int, LChar>(data, length, ok, base);
1036 }
1037
1038 int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
1039 {
1040     return toIntegralType<int, UChar>(data, length, ok, base);
1041 }
1042
1043 unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base)
1044 {
1045     return toIntegralType<unsigned, LChar>(data, length, ok, base);
1046 }
1047
1048 unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
1049 {
1050     return toIntegralType<unsigned, UChar>(data, length, ok, base);
1051 }
1052
1053 int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1054 {
1055     return toIntegralType<int64_t, LChar>(data, length, ok, base);
1056 }
1057
1058 int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1059 {
1060     return toIntegralType<int64_t, UChar>(data, length, ok, base);
1061 }
1062
1063 uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1064 {
1065     return toIntegralType<uint64_t, LChar>(data, length, ok, base);
1066 }
1067
1068 uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1069 {
1070     return toIntegralType<uint64_t, UChar>(data, length, ok, base);
1071 }
1072
1073 intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base)
1074 {
1075     return toIntegralType<intptr_t, LChar>(data, length, ok, base);
1076 }
1077
1078 intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base)
1079 {
1080     return toIntegralType<intptr_t, UChar>(data, length, ok, base);
1081 }
1082
1083 int charactersToInt(const LChar* data, size_t length, bool* ok)
1084 {
1085     return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1086 }
1087
1088 int charactersToInt(const UChar* data, size_t length, bool* ok)
1089 {
1090     return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
1091 }
1092
1093 unsigned charactersToUInt(const LChar* data, size_t length, bool* ok)
1094 {
1095     return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1096 }
1097
1098 unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
1099 {
1100     return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1101 }
1102
1103 int64_t charactersToInt64(const LChar* data, size_t length, bool* ok)
1104 {
1105     return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1106 }
1107
1108 int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
1109 {
1110     return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1111 }
1112
1113 uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok)
1114 {
1115     return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1116 }
1117
1118 uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
1119 {
1120     return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1121 }
1122
1123 intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok)
1124 {
1125     return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1126 }
1127
1128 intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok)
1129 {
1130     return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1131 }
1132
1133 enum TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk };
1134
1135 template <typename CharType, TrailingJunkPolicy policy>
1136 static inline double toDoubleType(const CharType* data, size_t length, bool* ok, size_t& parsedLength)
1137 {
1138     size_t leadingSpacesLength = 0;
1139     while (leadingSpacesLength < length && isASCIISpace(data[leadingSpacesLength]))
1140         ++leadingSpacesLength;
1141
1142     double number = parseDouble(data + leadingSpacesLength, length - leadingSpacesLength, parsedLength);
1143     if (!parsedLength) {
1144         if (ok)
1145             *ok = false;
1146         return 0.0;
1147     }
1148
1149     parsedLength += leadingSpacesLength;
1150     if (ok)
1151         *ok = policy == AllowTrailingJunk || parsedLength == length;
1152     return number;
1153 }
1154
1155 double charactersToDouble(const LChar* data, size_t length, bool* ok)
1156 {
1157     size_t parsedLength;
1158     return toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1159 }
1160
1161 double charactersToDouble(const UChar* data, size_t length, bool* ok)
1162 {
1163     size_t parsedLength;
1164     return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1165 }
1166
1167 float charactersToFloat(const LChar* data, size_t length, bool* ok)
1168 {
1169     // FIXME: This will return ok even when the string fits into a double but not a float.
1170     size_t parsedLength;
1171     return static_cast<float>(toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1172 }
1173
1174 float charactersToFloat(const UChar* data, size_t length, bool* ok)
1175 {
1176     // FIXME: This will return ok even when the string fits into a double but not a float.
1177     size_t parsedLength;
1178     return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1179 }
1180
1181 float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength)
1182 {
1183     // FIXME: This will return ok even when the string fits into a double but not a float.
1184     return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1185 }
1186
1187 float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength)
1188 {
1189     // FIXME: This will return ok even when the string fits into a double but not a float.
1190     return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1191 }
1192
1193 const String& emptyString()
1194 {
1195     DEFINE_STATIC_LOCAL(String, emptyString, (StringImpl::empty()));
1196     return emptyString;
1197 }
1198
1199 } // namespace WTF
1200
1201 #ifndef NDEBUG
1202 // For use in the debugger
1203 String* string(const char*);
1204 Vector<char> asciiDebug(StringImpl* impl);
1205 Vector<char> asciiDebug(String& string);
1206
1207 void String::show() const
1208 {
1209     dataLog("%s\n", asciiDebug(impl()).data());
1210 }
1211
1212 String* string(const char* s)
1213 {
1214     // leaks memory!
1215     return new String(s);
1216 }
1217
1218 Vector<char> asciiDebug(StringImpl* impl)
1219 {
1220     if (!impl)
1221         return asciiDebug(String("[null]").impl());
1222
1223     Vector<char> buffer;
1224     for (unsigned i = 0; i < impl->length(); ++i) {
1225         UChar ch = (*impl)[i];
1226         if (isASCIIPrintable(ch)) {
1227             if (ch == '\\')
1228                 buffer.append(ch);
1229             buffer.append(ch);
1230         } else {
1231             buffer.append('\\');
1232             buffer.append('u');
1233             appendUnsignedAsHexFixedSize(ch, buffer, 4);
1234         }
1235     }
1236     buffer.append('\0');
1237     return buffer;
1238 }
1239
1240 Vector<char> asciiDebug(String& string)
1241 {
1242     return asciiDebug(string.impl());
1243 }
1244
1245 #endif