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