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