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