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