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