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