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