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