Remove all uses of PassRefPtr in WTF
[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                 auto 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 = WTFMove(newImpl);
107                 return;
108             }
109             UChar* data;
110             if (str.length() > std::numeric_limits<unsigned>::max() - m_impl->length())
111                 CRASH();
112             auto 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 = WTFMove(newImpl);
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     auto 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 = WTFMove(newImpl);
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     auto newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data);
158     StringView(*m_impl).getCharactersWithUpconvert(data);
159     data[m_impl->length()] = character;
160     m_impl = WTFMove(newImpl);
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     if (is8Bit() && string.is8Bit()) {
191         LChar* data;
192         auto newString = StringImpl::createUninitialized(length() + lengthToInsert, data);
193         StringView(*m_impl).substring(0, position).getCharactersWithUpconvert(data);
194         StringView(string).getCharactersWithUpconvert(data + position);
195         StringView(*m_impl).substring(position).getCharactersWithUpconvert(data + position + lengthToInsert);
196         m_impl = WTFMove(newString);
197     } else {
198         UChar* data;
199         auto 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         m_impl = WTFMove(newString);
204     }
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         auto newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
230         StringImpl::copyChars(data, m_impl->characters8(), strLength);
231         StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
232         m_impl = WTFMove(newImpl);
233         return;
234     }
235
236     if (lengthToAppend > std::numeric_limits<unsigned>::max() - strLength)
237         CRASH();
238     UChar* data;
239     auto newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data);
240     StringImpl::copyChars(data, m_impl->characters16(), strLength);
241     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
242     m_impl = WTFMove(newImpl);
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     auto 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 = WTFMove(newImpl);
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     auto 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 = WTFMove(newImpl);
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::convertToASCIIUppercase() const
347 {
348     // FIXME: Should this function, and the many others like it, be inlined?
349     if (!m_impl)
350         return String();
351     return m_impl->convertToASCIIUppercase();
352 }
353
354 String String::convertToLowercaseWithoutLocale() const
355 {
356     if (!m_impl)
357         return String();
358     return m_impl->convertToLowercaseWithoutLocale();
359 }
360
361 String String::convertToUppercaseWithoutLocale() const
362 {
363     if (!m_impl)
364         return String();
365     return m_impl->convertToUppercaseWithoutLocale();
366 }
367
368 String String::convertToLowercaseWithLocale(const AtomicString& localeIdentifier) const
369 {
370     if (!m_impl)
371         return String();
372     return m_impl->convertToLowercaseWithLocale(localeIdentifier);
373 }
374
375 String String::convertToUppercaseWithLocale(const AtomicString& localeIdentifier) const
376 {
377     if (!m_impl)
378         return String();
379     return m_impl->convertToUppercaseWithLocale(localeIdentifier);
380 }
381
382 String String::stripWhiteSpace() const
383 {
384     if (!m_impl)
385         return String();
386     return m_impl->stripWhiteSpace();
387 }
388
389 String String::stripWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
390 {
391     if (!m_impl)
392         return String();
393     return m_impl->stripWhiteSpace(isWhiteSpace);
394 }
395
396 String String::simplifyWhiteSpace() const
397 {
398     if (!m_impl)
399         return String();
400     return m_impl->simplifyWhiteSpace();
401 }
402
403 String String::simplifyWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
404 {
405     if (!m_impl)
406         return String();
407     return m_impl->simplifyWhiteSpace(isWhiteSpace);
408 }
409
410 String String::removeCharacters(CharacterMatchFunctionPtr findMatch) const
411 {
412     if (!m_impl)
413         return String();
414     return m_impl->removeCharacters(findMatch);
415 }
416
417 String String::foldCase() const
418 {
419     if (!m_impl)
420         return String();
421     return m_impl->foldCase();
422 }
423
424 bool String::percentage(int& result) const
425 {
426     if (!m_impl || !m_impl->length())
427         return false;
428
429     if ((*m_impl)[m_impl->length() - 1] != '%')
430        return false;
431
432     if (m_impl->is8Bit())
433         result = charactersToIntStrict(m_impl->characters8(), m_impl->length() - 1);
434     else
435         result = charactersToIntStrict(m_impl->characters16(), m_impl->length() - 1);
436     return true;
437 }
438
439 Vector<UChar> String::charactersWithNullTermination() const
440 {
441     Vector<UChar> result;
442
443     if (m_impl) {
444         result.reserveInitialCapacity(length() + 1);
445
446         if (is8Bit()) {
447             const LChar* characters8 = m_impl->characters8();
448             for (size_t i = 0; i < length(); ++i)
449                 result.uncheckedAppend(characters8[i]);
450         } else {
451             const UChar* characters16 = m_impl->characters16();
452             result.append(characters16, m_impl->length());
453         }
454
455         result.append(0);
456     }
457
458     return result;
459 }
460
461 String String::format(const char *format, ...)
462 {
463     va_list args;
464     va_start(args, format);
465
466 #if USE(CF) && !OS(WINDOWS)
467     if (strstr(format, "%@")) {
468         RetainPtr<CFStringRef> cfFormat = adoptCF(CFStringCreateWithCString(kCFAllocatorDefault, format, kCFStringEncodingUTF8));
469
470 #if COMPILER(CLANG)
471 #pragma clang diagnostic push
472 #pragma clang diagnostic ignored "-Wformat-nonliteral"
473 #endif
474         RetainPtr<CFStringRef> result = adoptCF(CFStringCreateWithFormatAndArguments(kCFAllocatorDefault, nullptr, cfFormat.get(), args));
475 #if COMPILER(CLANG)
476 #pragma clang diagnostic pop
477 #endif
478
479         va_end(args);
480         return result.get();
481     }
482 #endif // USE(CF) && !OS(WINDOWS)
483
484     // Do the format once to get the length.
485 #if COMPILER(MSVC)
486     int result = _vscprintf(format, args);
487 #else
488     char ch;
489     int result = vsnprintf(&ch, 1, format, args);
490 #endif
491     va_end(args);
492
493     if (result == 0)
494         return String("");
495     if (result < 0)
496         return String();
497
498     Vector<char, 256> buffer;
499     unsigned len = result;
500     buffer.grow(len + 1);
501     
502     va_start(args, format);
503     // Now do the formatting again, guaranteed to fit.
504     vsnprintf(buffer.data(), buffer.size(), format, args);
505
506     va_end(args);
507     
508     return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), len);
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 #if COMPILER_SUPPORTS(CXX_REFERENCE_QUALIFIED_FUNCTIONS)
680 String String::isolatedCopy() const &
681 {
682     if (!m_impl)
683         return String();
684     return m_impl->isolatedCopy();
685 }
686
687 String String::isolatedCopy() &&
688 {
689     if (isSafeToSendToAnotherThread()) {
690         // Since we know that our string is a temporary that will be destroyed
691         // we can just steal the m_impl from it, thus avoiding a copy.
692         return String(WTFMove(*this));
693     }
694
695     if (!m_impl)
696         return String();
697
698     return m_impl->isolatedCopy();
699 }
700 #else
701 String String::isolatedCopy() const
702 {
703     if (!m_impl)
704         return String();
705     return m_impl->isolatedCopy();
706 }
707 #endif
708
709 bool String::isSafeToSendToAnotherThread() const
710 {
711     if (!impl())
712         return true;
713     if (isEmpty())
714         return true;
715     // AtomicStrings are not safe to send between threads as ~StringImpl()
716     // will try to remove them from the wrong AtomicStringTable.
717     if (impl()->isAtomic())
718         return false;
719     if (impl()->hasOneRef())
720         return true;
721     return false;
722 }
723
724 void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const
725 {
726     result.clear();
727
728     unsigned startPos = 0;
729     size_t endPos;
730     while ((endPos = find(separator, startPos)) != notFound) {
731         if (allowEmptyEntries || startPos != endPos)
732             result.append(substring(startPos, endPos - startPos));
733         startPos = endPos + separator.length();
734     }
735     if (allowEmptyEntries || startPos != length())
736         result.append(substring(startPos));
737 }
738
739 void String::split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const
740 {
741     result.clear();
742
743     unsigned startPos = 0;
744     size_t endPos;
745     while ((endPos = find(separator, startPos)) != notFound) {
746         if (allowEmptyEntries || startPos != endPos)
747             result.append(substring(startPos, endPos - startPos));
748         startPos = endPos + 1;
749     }
750     if (allowEmptyEntries || startPos != length())
751         result.append(substring(startPos));
752 }
753
754 CString String::ascii() const
755 {
756     // Printable ASCII characters 32..127 and the null character are
757     // preserved, characters outside of this range are converted to '?'.
758
759     unsigned length = this->length();
760     if (!length) { 
761         char* characterBuffer;
762         return CString::newUninitialized(length, characterBuffer);
763     }
764
765     if (this->is8Bit()) {
766         const LChar* characters = this->characters8();
767
768         char* characterBuffer;
769         CString result = CString::newUninitialized(length, characterBuffer);
770
771         for (unsigned i = 0; i < length; ++i) {
772             LChar ch = characters[i];
773             characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
774         }
775
776         return result;        
777     }
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 && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
787     }
788
789     return result;
790 }
791
792 CString String::latin1() const
793 {
794     // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are
795     // preserved, characters outside of this range are converted to '?'.
796
797     unsigned length = this->length();
798
799     if (!length)
800         return CString("", 0);
801
802     if (is8Bit())
803         return CString(reinterpret_cast<const char*>(this->characters8()), length);
804
805     const UChar* characters = this->characters16();
806
807     char* characterBuffer;
808     CString result = CString::newUninitialized(length, characterBuffer);
809
810     for (unsigned i = 0; i < length; ++i) {
811         UChar ch = characters[i];
812         characterBuffer[i] = ch > 0xff ? '?' : ch;
813     }
814
815     return result;
816 }
817
818 CString String::utf8(ConversionMode mode) const
819 {
820     if (!m_impl)
821         return CString("", 0);
822     
823     return m_impl->utf8(mode);
824 }
825
826 CString String::utf8() const
827 {
828     return utf8(LenientConversion);
829 }
830
831 String String::make8BitFrom16BitSource(const UChar* source, size_t length)
832 {
833     if (!length)
834         return String();
835
836     LChar* destination;
837     String result = String::createUninitialized(length, destination);
838
839     copyLCharsFromUCharSource(destination, source, length);
840
841     return result;
842 }
843
844 String String::make16BitFrom8BitSource(const LChar* source, size_t length)
845 {
846     if (!length)
847         return String();
848     
849     UChar* destination;
850     String result = String::createUninitialized(length, destination);
851     
852     StringImpl::copyChars(destination, source, length);
853     
854     return result;
855 }
856
857 String String::fromUTF8(const LChar* stringStart, size_t length)
858 {
859     if (length > std::numeric_limits<unsigned>::max())
860         CRASH();
861
862     if (!stringStart)
863         return String();
864
865     if (!length)
866         return emptyString();
867
868     if (charactersAreAllASCII(stringStart, length))
869         return StringImpl::create(stringStart, length);
870
871     Vector<UChar, 1024> buffer(length);
872     UChar* bufferStart = buffer.data();
873  
874     UChar* bufferCurrent = bufferStart;
875     const char* stringCurrent = reinterpret_cast<const char*>(stringStart);
876     if (convertUTF8ToUTF16(&stringCurrent, reinterpret_cast<const char *>(stringStart + length), &bufferCurrent, bufferCurrent + buffer.size()) != conversionOK)
877         return String();
878
879     unsigned utf16Length = bufferCurrent - bufferStart;
880     ASSERT_WITH_SECURITY_IMPLICATION(utf16Length < length);
881     return StringImpl::create(bufferStart, utf16Length);
882 }
883
884 String String::fromUTF8(const LChar* string)
885 {
886     if (!string)
887         return String();
888     return fromUTF8(string, strlen(reinterpret_cast<const char*>(string)));
889 }
890
891 String String::fromUTF8(const CString& s)
892 {
893     return fromUTF8(s.data());
894 }
895
896 String String::fromUTF8WithLatin1Fallback(const LChar* string, size_t size)
897 {
898     String utf8 = fromUTF8(string, size);
899     if (!utf8)
900         return String(string, size);
901     return utf8;
902 }
903
904 // String Operations
905
906 static bool isCharacterAllowedInBase(UChar c, int base)
907 {
908     if (c > 0x7F)
909         return false;
910     if (isASCIIDigit(c))
911         return c - '0' < base;
912     if (isASCIIAlpha(c)) {
913         if (base > 36)
914             base = 36;
915         return (c >= 'a' && c < 'a' + base - 10)
916             || (c >= 'A' && c < 'A' + base - 10);
917     }
918     return false;
919 }
920
921 template <typename IntegralType, typename CharType>
922 static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
923 {
924     static const IntegralType integralMax = std::numeric_limits<IntegralType>::max();
925     static const bool isSigned = std::numeric_limits<IntegralType>::is_signed;
926     const IntegralType maxMultiplier = integralMax / base;
927
928     IntegralType value = 0;
929     bool isOk = false;
930     bool isNegative = false;
931
932     if (!data)
933         goto bye;
934
935     // skip leading whitespace
936     while (length && isSpaceOrNewline(*data)) {
937         --length;
938         ++data;
939     }
940
941     if (isSigned && length && *data == '-') {
942         --length;
943         ++data;
944         isNegative = true;
945     } else if (length && *data == '+') {
946         --length;
947         ++data;
948     }
949
950     if (!length || !isCharacterAllowedInBase(*data, base))
951         goto bye;
952
953     while (length && isCharacterAllowedInBase(*data, base)) {
954         --length;
955         IntegralType digitValue;
956         CharType c = *data;
957         if (isASCIIDigit(c))
958             digitValue = c - '0';
959         else if (c >= 'a')
960             digitValue = c - 'a' + 10;
961         else
962             digitValue = c - 'A' + 10;
963
964         if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative))
965             goto bye;
966
967         value = base * value + digitValue;
968         ++data;
969     }
970
971 #if COMPILER(MSVC)
972 #pragma warning(push, 0)
973 #pragma warning(disable:4146)
974 #endif
975
976     if (isNegative)
977         value = -value;
978
979 #if COMPILER(MSVC)
980 #pragma warning(pop)
981 #endif
982
983     // skip trailing space
984     while (length && isSpaceOrNewline(*data)) {
985         --length;
986         ++data;
987     }
988
989     if (!length)
990         isOk = true;
991 bye:
992     if (ok)
993         *ok = isOk;
994     return isOk ? value : 0;
995 }
996
997 template <typename CharType>
998 static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length)
999 {
1000     size_t i = 0;
1001
1002     // Allow leading spaces.
1003     for (; i != length; ++i) {
1004         if (!isSpaceOrNewline(data[i]))
1005             break;
1006     }
1007     
1008     // Allow sign.
1009     if (i != length && (data[i] == '+' || data[i] == '-'))
1010         ++i;
1011     
1012     // Allow digits.
1013     for (; i != length; ++i) {
1014         if (!isASCIIDigit(data[i]))
1015             break;
1016     }
1017
1018     return i;
1019 }
1020
1021 int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base)
1022 {
1023     return toIntegralType<int, LChar>(data, length, ok, base);
1024 }
1025
1026 int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
1027 {
1028     return toIntegralType<int, UChar>(data, length, ok, base);
1029 }
1030
1031 unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base)
1032 {
1033     return toIntegralType<unsigned, LChar>(data, length, ok, base);
1034 }
1035
1036 unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
1037 {
1038     return toIntegralType<unsigned, UChar>(data, length, ok, base);
1039 }
1040
1041 int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1042 {
1043     return toIntegralType<int64_t, LChar>(data, length, ok, base);
1044 }
1045
1046 int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1047 {
1048     return toIntegralType<int64_t, UChar>(data, length, ok, base);
1049 }
1050
1051 uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1052 {
1053     return toIntegralType<uint64_t, LChar>(data, length, ok, base);
1054 }
1055
1056 uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1057 {
1058     return toIntegralType<uint64_t, UChar>(data, length, ok, base);
1059 }
1060
1061 intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base)
1062 {
1063     return toIntegralType<intptr_t, LChar>(data, length, ok, base);
1064 }
1065
1066 intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base)
1067 {
1068     return toIntegralType<intptr_t, UChar>(data, length, ok, base);
1069 }
1070
1071 int charactersToInt(const LChar* data, size_t length, bool* ok)
1072 {
1073     return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1074 }
1075
1076 int charactersToInt(const UChar* data, size_t length, bool* ok)
1077 {
1078     return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
1079 }
1080
1081 unsigned charactersToUInt(const LChar* data, size_t length, bool* ok)
1082 {
1083     return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1084 }
1085
1086 unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
1087 {
1088     return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1089 }
1090
1091 int64_t charactersToInt64(const LChar* data, size_t length, bool* ok)
1092 {
1093     return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1094 }
1095
1096 int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
1097 {
1098     return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1099 }
1100
1101 uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok)
1102 {
1103     return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1104 }
1105
1106 uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
1107 {
1108     return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1109 }
1110
1111 intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok)
1112 {
1113     return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1114 }
1115
1116 intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok)
1117 {
1118     return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1119 }
1120
1121 enum TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk };
1122
1123 template <typename CharType, TrailingJunkPolicy policy>
1124 static inline double toDoubleType(const CharType* data, size_t length, bool* ok, size_t& parsedLength)
1125 {
1126     size_t leadingSpacesLength = 0;
1127     while (leadingSpacesLength < length && isASCIISpace(data[leadingSpacesLength]))
1128         ++leadingSpacesLength;
1129
1130     double number = parseDouble(data + leadingSpacesLength, length - leadingSpacesLength, parsedLength);
1131     if (!parsedLength) {
1132         if (ok)
1133             *ok = false;
1134         return 0.0;
1135     }
1136
1137     parsedLength += leadingSpacesLength;
1138     if (ok)
1139         *ok = policy == AllowTrailingJunk || parsedLength == length;
1140     return number;
1141 }
1142
1143 double charactersToDouble(const LChar* data, size_t length, bool* ok)
1144 {
1145     size_t parsedLength;
1146     return toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1147 }
1148
1149 double charactersToDouble(const UChar* data, size_t length, bool* ok)
1150 {
1151     size_t parsedLength;
1152     return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1153 }
1154
1155 float charactersToFloat(const LChar* data, size_t length, bool* ok)
1156 {
1157     // FIXME: This will return ok even when the string fits into a double but not a float.
1158     size_t parsedLength;
1159     return static_cast<float>(toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1160 }
1161
1162 float charactersToFloat(const UChar* data, size_t length, bool* ok)
1163 {
1164     // FIXME: This will return ok even when the string fits into a double but not a float.
1165     size_t parsedLength;
1166     return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1167 }
1168
1169 float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength)
1170 {
1171     // FIXME: This will return ok even when the string fits into a double but not a float.
1172     return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1173 }
1174
1175 float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength)
1176 {
1177     // FIXME: This will return ok even when the string fits into a double but not a float.
1178     return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1179 }
1180
1181 const String& emptyString()
1182 {
1183     static NeverDestroyed<String> emptyString(StringImpl::empty());
1184
1185     return emptyString;
1186 }
1187
1188 } // namespace WTF
1189
1190 #ifndef NDEBUG
1191 // For use in the debugger
1192 String* string(const char*);
1193 Vector<char> asciiDebug(StringImpl* impl);
1194 Vector<char> asciiDebug(String& string);
1195
1196 void String::show() const
1197 {
1198     dataLogF("%s\n", asciiDebug(impl()).data());
1199 }
1200
1201 String* string(const char* s)
1202 {
1203     // leaks memory!
1204     return new String(s);
1205 }
1206
1207 Vector<char> asciiDebug(StringImpl* impl)
1208 {
1209     if (!impl)
1210         return asciiDebug(String(ASCIILiteral("[null]")).impl());
1211
1212     Vector<char> buffer;
1213     for (unsigned i = 0; i < impl->length(); ++i) {
1214         UChar ch = (*impl)[i];
1215         if (isASCIIPrintable(ch)) {
1216             if (ch == '\\')
1217                 buffer.append(ch);
1218             buffer.append(ch);
1219         } else {
1220             buffer.append('\\');
1221             buffer.append('u');
1222             appendUnsignedAsHexFixedSize(ch, buffer, 4);
1223         }
1224     }
1225     buffer.append('\0');
1226     return buffer;
1227 }
1228
1229 Vector<char> asciiDebug(String& string)
1230 {
1231     return asciiDebug(string.impl());
1232 }
1233
1234 #endif