899a44ce048bb14e835ff71d7c5100f76384a017
[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     if (!length)
881         return emptyString();
882
883     // We'll use a StringImpl as a buffer; if the source string only contains ascii this should be
884     // the right length, if there are any multi-byte sequences this buffer will be too large.
885     UChar* buffer;
886     String stringBuffer(StringImpl::createUninitialized(length, buffer));
887     UChar* bufferEnd = buffer + length;
888  
889     // Try converting into the buffer.
890     const char* stringCurrent = reinterpret_cast<const char*>(stringStart);
891     bool isAllASCII;
892     if (convertUTF8ToUTF16(&stringCurrent, reinterpret_cast<const char *>(stringStart + length), &buffer, bufferEnd, &isAllASCII) != conversionOK)
893         return String();
894
895     if (isAllASCII)
896         return String(stringStart, length);
897
898     // stringBuffer is full (the input must have been all ascii) so just return it!
899     if (buffer == bufferEnd)
900         return stringBuffer;
901
902     // stringBuffer served its purpose as a buffer, copy the contents out into a new string.
903     unsigned utf16Length = buffer - stringBuffer.characters();
904     ASSERT(utf16Length < length);
905     return String(stringBuffer.characters(), utf16Length);
906 }
907
908 String String::fromUTF8(const LChar* string)
909 {
910     if (!string)
911         return String();
912     return fromUTF8(string, strlen(reinterpret_cast<const char*>(string)));
913 }
914
915 String String::fromUTF8WithLatin1Fallback(const LChar* string, size_t size)
916 {
917     String utf8 = fromUTF8(string, size);
918     if (!utf8)
919         return String(string, size);
920     return utf8;
921 }
922
923 // String Operations
924
925 static bool isCharacterAllowedInBase(UChar c, int base)
926 {
927     if (c > 0x7F)
928         return false;
929     if (isASCIIDigit(c))
930         return c - '0' < base;
931     if (isASCIIAlpha(c)) {
932         if (base > 36)
933             base = 36;
934         return (c >= 'a' && c < 'a' + base - 10)
935             || (c >= 'A' && c < 'A' + base - 10);
936     }
937     return false;
938 }
939
940 template <typename IntegralType, typename CharType>
941 static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
942 {
943     static const IntegralType integralMax = numeric_limits<IntegralType>::max();
944     static const bool isSigned = numeric_limits<IntegralType>::is_signed;
945     const IntegralType maxMultiplier = integralMax / base;
946
947     IntegralType value = 0;
948     bool isOk = false;
949     bool isNegative = false;
950
951     if (!data)
952         goto bye;
953
954     // skip leading whitespace
955     while (length && isSpaceOrNewline(*data)) {
956         --length;
957         ++data;
958     }
959
960     if (isSigned && length && *data == '-') {
961         --length;
962         ++data;
963         isNegative = true;
964     } else if (length && *data == '+') {
965         --length;
966         ++data;
967     }
968
969     if (!length || !isCharacterAllowedInBase(*data, base))
970         goto bye;
971
972     while (length && isCharacterAllowedInBase(*data, base)) {
973         --length;
974         IntegralType digitValue;
975         CharType c = *data;
976         if (isASCIIDigit(c))
977             digitValue = c - '0';
978         else if (c >= 'a')
979             digitValue = c - 'a' + 10;
980         else
981             digitValue = c - 'A' + 10;
982
983         if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative))
984             goto bye;
985
986         value = base * value + digitValue;
987         ++data;
988     }
989
990 #if COMPILER(MSVC)
991 #pragma warning(push, 0)
992 #pragma warning(disable:4146)
993 #endif
994
995     if (isNegative)
996         value = -value;
997
998 #if COMPILER(MSVC)
999 #pragma warning(pop)
1000 #endif
1001
1002     // skip trailing space
1003     while (length && isSpaceOrNewline(*data)) {
1004         --length;
1005         ++data;
1006     }
1007
1008     if (!length)
1009         isOk = true;
1010 bye:
1011     if (ok)
1012         *ok = isOk;
1013     return isOk ? value : 0;
1014 }
1015
1016 template <typename CharType>
1017 static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length)
1018 {
1019     size_t i = 0;
1020
1021     // Allow leading spaces.
1022     for (; i != length; ++i) {
1023         if (!isSpaceOrNewline(data[i]))
1024             break;
1025     }
1026     
1027     // Allow sign.
1028     if (i != length && (data[i] == '+' || data[i] == '-'))
1029         ++i;
1030     
1031     // Allow digits.
1032     for (; i != length; ++i) {
1033         if (!isASCIIDigit(data[i]))
1034             break;
1035     }
1036
1037     return i;
1038 }
1039
1040 int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base)
1041 {
1042     return toIntegralType<int, LChar>(data, length, ok, base);
1043 }
1044
1045 int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
1046 {
1047     return toIntegralType<int, UChar>(data, length, ok, base);
1048 }
1049
1050 unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base)
1051 {
1052     return toIntegralType<unsigned, LChar>(data, length, ok, base);
1053 }
1054
1055 unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
1056 {
1057     return toIntegralType<unsigned, UChar>(data, length, ok, base);
1058 }
1059
1060 int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1061 {
1062     return toIntegralType<int64_t, LChar>(data, length, ok, base);
1063 }
1064
1065 int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1066 {
1067     return toIntegralType<int64_t, UChar>(data, length, ok, base);
1068 }
1069
1070 uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1071 {
1072     return toIntegralType<uint64_t, LChar>(data, length, ok, base);
1073 }
1074
1075 uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1076 {
1077     return toIntegralType<uint64_t, UChar>(data, length, ok, base);
1078 }
1079
1080 intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base)
1081 {
1082     return toIntegralType<intptr_t, LChar>(data, length, ok, base);
1083 }
1084
1085 intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base)
1086 {
1087     return toIntegralType<intptr_t, UChar>(data, length, ok, base);
1088 }
1089
1090 int charactersToInt(const LChar* data, size_t length, bool* ok)
1091 {
1092     return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1093 }
1094
1095 int charactersToInt(const UChar* data, size_t length, bool* ok)
1096 {
1097     return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
1098 }
1099
1100 unsigned charactersToUInt(const LChar* data, size_t length, bool* ok)
1101 {
1102     return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1103 }
1104
1105 unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
1106 {
1107     return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1108 }
1109
1110 int64_t charactersToInt64(const LChar* data, size_t length, bool* ok)
1111 {
1112     return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1113 }
1114
1115 int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
1116 {
1117     return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1118 }
1119
1120 uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok)
1121 {
1122     return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1123 }
1124
1125 uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
1126 {
1127     return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1128 }
1129
1130 intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok)
1131 {
1132     return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1133 }
1134
1135 intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok)
1136 {
1137     return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1138 }
1139
1140 enum TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk };
1141
1142 template <typename CharType, TrailingJunkPolicy policy>
1143 static inline double toDoubleType(const CharType* data, size_t length, bool* ok, size_t& parsedLength)
1144 {
1145     size_t leadingSpacesLength = 0;
1146     while (leadingSpacesLength < length && isASCIISpace(data[leadingSpacesLength]))
1147         ++leadingSpacesLength;
1148
1149     double number = parseDouble(data + leadingSpacesLength, length - leadingSpacesLength, parsedLength);
1150     if (!parsedLength) {
1151         if (ok)
1152             *ok = false;
1153         return 0.0;
1154     }
1155
1156     parsedLength += leadingSpacesLength;
1157     if (ok)
1158         *ok = policy == AllowTrailingJunk || parsedLength == length;
1159     return number;
1160 }
1161
1162 double charactersToDouble(const LChar* data, size_t length, bool* ok)
1163 {
1164     size_t parsedLength;
1165     return toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1166 }
1167
1168 double charactersToDouble(const UChar* data, size_t length, bool* ok)
1169 {
1170     size_t parsedLength;
1171     return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1172 }
1173
1174 float charactersToFloat(const LChar* 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<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1179 }
1180
1181 float charactersToFloat(const UChar* data, size_t length, bool* ok)
1182 {
1183     // FIXME: This will return ok even when the string fits into a double but not a float.
1184     size_t parsedLength;
1185     return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1186 }
1187
1188 float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength)
1189 {
1190     // FIXME: This will return ok even when the string fits into a double but not a float.
1191     return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1192 }
1193
1194 float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength)
1195 {
1196     // FIXME: This will return ok even when the string fits into a double but not a float.
1197     return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1198 }
1199
1200 const String& emptyString()
1201 {
1202     DEFINE_STATIC_LOCAL(String, emptyString, (StringImpl::empty()));
1203     return emptyString;
1204 }
1205
1206 } // namespace WTF
1207
1208 #ifndef NDEBUG
1209 // For use in the debugger
1210 String* string(const char*);
1211 Vector<char> asciiDebug(StringImpl* impl);
1212 Vector<char> asciiDebug(String& string);
1213
1214 void String::show() const
1215 {
1216     dataLog("%s\n", asciiDebug(impl()).data());
1217 }
1218
1219 String* string(const char* s)
1220 {
1221     // leaks memory!
1222     return new String(s);
1223 }
1224
1225 Vector<char> asciiDebug(StringImpl* impl)
1226 {
1227     if (!impl)
1228         return asciiDebug(String("[null]").impl());
1229
1230     Vector<char> buffer;
1231     for (unsigned i = 0; i < impl->length(); ++i) {
1232         UChar ch = (*impl)[i];
1233         if (isASCIIPrintable(ch)) {
1234             if (ch == '\\')
1235                 buffer.append(ch);
1236             buffer.append(ch);
1237         } else {
1238             buffer.append('\\');
1239             buffer.append('u');
1240             appendUnsignedAsHexFixedSize(ch, buffer, 4);
1241         }
1242     }
1243     buffer.append('\0');
1244     return buffer;
1245 }
1246
1247 Vector<char> asciiDebug(String& string)
1248 {
1249     return asciiDebug(string.impl());
1250 }
1251
1252 #endif