dbe6eeab171687d952a0b15efe76afab3703107f
[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::convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(unsigned failingIndex) const
362 {
363     if (!m_impl)
364         return String();
365     return m_impl->convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(failingIndex);
366 }
367
368 String String::convertToUppercaseWithoutLocale() const
369 {
370     if (!m_impl)
371         return String();
372     return m_impl->convertToUppercaseWithoutLocale();
373 }
374
375 String String::convertToLowercaseWithLocale(const AtomicString& localeIdentifier) const
376 {
377     if (!m_impl)
378         return String();
379     return m_impl->convertToLowercaseWithLocale(localeIdentifier);
380 }
381
382 String String::convertToUppercaseWithLocale(const AtomicString& localeIdentifier) const
383 {
384     if (!m_impl)
385         return String();
386     return m_impl->convertToUppercaseWithLocale(localeIdentifier);
387 }
388
389 String String::stripWhiteSpace() const
390 {
391     if (!m_impl)
392         return String();
393     return m_impl->stripWhiteSpace();
394 }
395
396 String String::stripWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
397 {
398     if (!m_impl)
399         return String();
400     return m_impl->stripWhiteSpace(isWhiteSpace);
401 }
402
403 String String::simplifyWhiteSpace() const
404 {
405     if (!m_impl)
406         return String();
407     return m_impl->simplifyWhiteSpace();
408 }
409
410 String String::simplifyWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const
411 {
412     if (!m_impl)
413         return String();
414     return m_impl->simplifyWhiteSpace(isWhiteSpace);
415 }
416
417 String String::removeCharacters(CharacterMatchFunctionPtr findMatch) const
418 {
419     if (!m_impl)
420         return String();
421     return m_impl->removeCharacters(findMatch);
422 }
423
424 String String::foldCase() const
425 {
426     if (!m_impl)
427         return String();
428     return m_impl->foldCase();
429 }
430
431 bool String::percentage(int& result) const
432 {
433     if (!m_impl || !m_impl->length())
434         return false;
435
436     if ((*m_impl)[m_impl->length() - 1] != '%')
437        return false;
438
439     if (m_impl->is8Bit())
440         result = charactersToIntStrict(m_impl->characters8(), m_impl->length() - 1);
441     else
442         result = charactersToIntStrict(m_impl->characters16(), m_impl->length() - 1);
443     return true;
444 }
445
446 Vector<UChar> String::charactersWithNullTermination() const
447 {
448     Vector<UChar> result;
449
450     if (m_impl) {
451         result.reserveInitialCapacity(length() + 1);
452
453         if (is8Bit()) {
454             const LChar* characters8 = m_impl->characters8();
455             for (size_t i = 0; i < length(); ++i)
456                 result.uncheckedAppend(characters8[i]);
457         } else {
458             const UChar* characters16 = m_impl->characters16();
459             result.append(characters16, m_impl->length());
460         }
461
462         result.append(0);
463     }
464
465     return result;
466 }
467
468 String String::format(const char *format, ...)
469 {
470     va_list args;
471     va_start(args, format);
472
473 #if USE(CF) && !OS(WINDOWS)
474     if (strstr(format, "%@")) {
475         RetainPtr<CFStringRef> cfFormat = adoptCF(CFStringCreateWithCString(kCFAllocatorDefault, format, kCFStringEncodingUTF8));
476
477 #if COMPILER(CLANG)
478 #pragma clang diagnostic push
479 #pragma clang diagnostic ignored "-Wformat-nonliteral"
480 #endif
481         RetainPtr<CFStringRef> result = adoptCF(CFStringCreateWithFormatAndArguments(kCFAllocatorDefault, nullptr, cfFormat.get(), args));
482 #if COMPILER(CLANG)
483 #pragma clang diagnostic pop
484 #endif
485
486         va_end(args);
487         return result.get();
488     }
489 #endif // USE(CF) && !OS(WINDOWS)
490
491     // Do the format once to get the length.
492 #if COMPILER(MSVC)
493     int result = _vscprintf(format, args);
494 #else
495     char ch;
496     int result = vsnprintf(&ch, 1, format, args);
497 #endif
498     va_end(args);
499
500     if (result == 0)
501         return String("");
502     if (result < 0)
503         return String();
504
505     Vector<char, 256> buffer;
506     unsigned len = result;
507     buffer.grow(len + 1);
508     
509     va_start(args, format);
510     // Now do the formatting again, guaranteed to fit.
511     vsnprintf(buffer.data(), buffer.size(), format, args);
512
513     va_end(args);
514     
515     return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), len);
516 }
517
518 String String::number(int number)
519 {
520     return numberToStringSigned<String>(number);
521 }
522
523 String String::number(unsigned int number)
524 {
525     return numberToStringUnsigned<String>(number);
526 }
527
528 String String::number(long number)
529 {
530     return numberToStringSigned<String>(number);
531 }
532
533 String String::number(unsigned long number)
534 {
535     return numberToStringUnsigned<String>(number);
536 }
537
538 String String::number(long long number)
539 {
540     return numberToStringSigned<String>(number);
541 }
542
543 String String::number(unsigned long long number)
544 {
545     return numberToStringUnsigned<String>(number);
546 }
547
548 String String::number(double number, unsigned precision, TrailingZerosTruncatingPolicy trailingZerosTruncatingPolicy)
549 {
550     NumberToStringBuffer buffer;
551     return String(numberToFixedPrecisionString(number, precision, buffer, trailingZerosTruncatingPolicy == TruncateTrailingZeros));
552 }
553
554 String String::numberToStringECMAScript(double number)
555 {
556     NumberToStringBuffer buffer;
557     return String(numberToString(number, buffer));
558 }
559
560 String String::numberToStringFixedWidth(double number, unsigned decimalPlaces)
561 {
562     NumberToStringBuffer buffer;
563     return String(numberToFixedWidthString(number, decimalPlaces, buffer));
564 }
565
566 int String::toIntStrict(bool* ok, int base) const
567 {
568     if (!m_impl) {
569         if (ok)
570             *ok = false;
571         return 0;
572     }
573     return m_impl->toIntStrict(ok, base);
574 }
575
576 unsigned String::toUIntStrict(bool* ok, int base) const
577 {
578     if (!m_impl) {
579         if (ok)
580             *ok = false;
581         return 0;
582     }
583     return m_impl->toUIntStrict(ok, base);
584 }
585
586 int64_t String::toInt64Strict(bool* ok, int base) const
587 {
588     if (!m_impl) {
589         if (ok)
590             *ok = false;
591         return 0;
592     }
593     return m_impl->toInt64Strict(ok, base);
594 }
595
596 uint64_t String::toUInt64Strict(bool* ok, int base) const
597 {
598     if (!m_impl) {
599         if (ok)
600             *ok = false;
601         return 0;
602     }
603     return m_impl->toUInt64Strict(ok, base);
604 }
605
606 intptr_t String::toIntPtrStrict(bool* ok, int base) const
607 {
608     if (!m_impl) {
609         if (ok)
610             *ok = false;
611         return 0;
612     }
613     return m_impl->toIntPtrStrict(ok, base);
614 }
615
616 int String::toInt(bool* ok) const
617 {
618     if (!m_impl) {
619         if (ok)
620             *ok = false;
621         return 0;
622     }
623     return m_impl->toInt(ok);
624 }
625
626 unsigned String::toUInt(bool* ok) const
627 {
628     if (!m_impl) {
629         if (ok)
630             *ok = false;
631         return 0;
632     }
633     return m_impl->toUInt(ok);
634 }
635
636 int64_t String::toInt64(bool* ok) const
637 {
638     if (!m_impl) {
639         if (ok)
640             *ok = false;
641         return 0;
642     }
643     return m_impl->toInt64(ok);
644 }
645
646 uint64_t String::toUInt64(bool* ok) const
647 {
648     if (!m_impl) {
649         if (ok)
650             *ok = false;
651         return 0;
652     }
653     return m_impl->toUInt64(ok);
654 }
655
656 intptr_t String::toIntPtr(bool* ok) const
657 {
658     if (!m_impl) {
659         if (ok)
660             *ok = false;
661         return 0;
662     }
663     return m_impl->toIntPtr(ok);
664 }
665
666 double String::toDouble(bool* ok) const
667 {
668     if (!m_impl) {
669         if (ok)
670             *ok = false;
671         return 0.0;
672     }
673     return m_impl->toDouble(ok);
674 }
675
676 float String::toFloat(bool* ok) const
677 {
678     if (!m_impl) {
679         if (ok)
680             *ok = false;
681         return 0.0f;
682     }
683     return m_impl->toFloat(ok);
684 }
685
686 #if COMPILER_SUPPORTS(CXX_REFERENCE_QUALIFIED_FUNCTIONS)
687 String String::isolatedCopy() const &
688 {
689     if (!m_impl)
690         return String();
691     return m_impl->isolatedCopy();
692 }
693
694 String String::isolatedCopy() &&
695 {
696     if (isSafeToSendToAnotherThread()) {
697         // Since we know that our string is a temporary that will be destroyed
698         // we can just steal the m_impl from it, thus avoiding a copy.
699         return String(WTFMove(*this));
700     }
701
702     if (!m_impl)
703         return String();
704
705     return m_impl->isolatedCopy();
706 }
707 #else
708 String String::isolatedCopy() const
709 {
710     if (!m_impl)
711         return String();
712     return m_impl->isolatedCopy();
713 }
714 #endif
715
716 bool String::isSafeToSendToAnotherThread() const
717 {
718     if (!impl())
719         return true;
720     if (isEmpty())
721         return true;
722     // AtomicStrings are not safe to send between threads as ~StringImpl()
723     // will try to remove them from the wrong AtomicStringTable.
724     if (impl()->isAtomic())
725         return false;
726     if (impl()->hasOneRef())
727         return true;
728     return false;
729 }
730
731 void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const
732 {
733     result.clear();
734
735     unsigned startPos = 0;
736     size_t endPos;
737     while ((endPos = find(separator, startPos)) != notFound) {
738         if (allowEmptyEntries || startPos != endPos)
739             result.append(substring(startPos, endPos - startPos));
740         startPos = endPos + separator.length();
741     }
742     if (allowEmptyEntries || startPos != length())
743         result.append(substring(startPos));
744 }
745
746 void String::split(UChar separator, bool allowEmptyEntries, const SplitFunctor& functor) const
747 {
748     StringView view(*this);
749
750     unsigned startPos = 0;
751     size_t endPos;
752     while ((endPos = find(separator, startPos)) != notFound) {
753         if (allowEmptyEntries || startPos != endPos)
754             functor(view.substring(startPos, endPos - startPos));
755         startPos = endPos + 1;
756     }
757     if (allowEmptyEntries || startPos != length())
758         functor(view.substring(startPos));
759 }
760
761 void String::split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const
762 {
763     result.clear();
764     split(separator, allowEmptyEntries, [&result](StringView item) {
765         result.append(item.toString());
766     });
767 }
768
769 CString String::ascii() const
770 {
771     // Printable ASCII characters 32..127 and the null character are
772     // preserved, characters outside of this range are converted to '?'.
773
774     unsigned length = this->length();
775     if (!length) { 
776         char* characterBuffer;
777         return CString::newUninitialized(length, characterBuffer);
778     }
779
780     if (this->is8Bit()) {
781         const LChar* characters = this->characters8();
782
783         char* characterBuffer;
784         CString result = CString::newUninitialized(length, characterBuffer);
785
786         for (unsigned i = 0; i < length; ++i) {
787             LChar ch = characters[i];
788             characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
789         }
790
791         return result;        
792     }
793
794     const UChar* characters = this->characters16();
795
796     char* characterBuffer;
797     CString result = CString::newUninitialized(length, characterBuffer);
798
799     for (unsigned i = 0; i < length; ++i) {
800         UChar ch = characters[i];
801         characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch;
802     }
803
804     return result;
805 }
806
807 CString String::latin1() const
808 {
809     // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are
810     // preserved, characters outside of this range are converted to '?'.
811
812     unsigned length = this->length();
813
814     if (!length)
815         return CString("", 0);
816
817     if (is8Bit())
818         return CString(reinterpret_cast<const char*>(this->characters8()), length);
819
820     const UChar* characters = this->characters16();
821
822     char* characterBuffer;
823     CString result = CString::newUninitialized(length, characterBuffer);
824
825     for (unsigned i = 0; i < length; ++i) {
826         UChar ch = characters[i];
827         characterBuffer[i] = ch > 0xff ? '?' : ch;
828     }
829
830     return result;
831 }
832
833 CString String::utf8(ConversionMode mode) const
834 {
835     if (!m_impl)
836         return CString("", 0);
837     
838     return m_impl->utf8(mode);
839 }
840
841 CString String::utf8() const
842 {
843     return utf8(LenientConversion);
844 }
845
846 String String::make8BitFrom16BitSource(const UChar* source, size_t length)
847 {
848     if (!length)
849         return String();
850
851     LChar* destination;
852     String result = String::createUninitialized(length, destination);
853
854     copyLCharsFromUCharSource(destination, source, length);
855
856     return result;
857 }
858
859 String String::make16BitFrom8BitSource(const LChar* source, size_t length)
860 {
861     if (!length)
862         return String();
863     
864     UChar* destination;
865     String result = String::createUninitialized(length, destination);
866     
867     StringImpl::copyChars(destination, source, length);
868     
869     return result;
870 }
871
872 String String::fromUTF8(const LChar* stringStart, size_t length)
873 {
874     if (length > std::numeric_limits<unsigned>::max())
875         CRASH();
876
877     if (!stringStart)
878         return String();
879
880     if (!length)
881         return emptyString();
882
883     if (charactersAreAllASCII(stringStart, length))
884         return StringImpl::create(stringStart, length);
885
886     Vector<UChar, 1024> buffer(length);
887     UChar* bufferStart = buffer.data();
888  
889     UChar* bufferCurrent = bufferStart;
890     const char* stringCurrent = reinterpret_cast<const char*>(stringStart);
891     if (convertUTF8ToUTF16(&stringCurrent, reinterpret_cast<const char *>(stringStart + length), &bufferCurrent, bufferCurrent + buffer.size()) != conversionOK)
892         return String();
893
894     unsigned utf16Length = bufferCurrent - bufferStart;
895     ASSERT_WITH_SECURITY_IMPLICATION(utf16Length < length);
896     return StringImpl::create(bufferStart, utf16Length);
897 }
898
899 String String::fromUTF8(const LChar* string)
900 {
901     if (!string)
902         return String();
903     return fromUTF8(string, strlen(reinterpret_cast<const char*>(string)));
904 }
905
906 String String::fromUTF8(const CString& s)
907 {
908     return fromUTF8(s.data());
909 }
910
911 String String::fromUTF8WithLatin1Fallback(const LChar* string, size_t size)
912 {
913     String utf8 = fromUTF8(string, size);
914     if (!utf8)
915         return String(string, size);
916     return utf8;
917 }
918
919 // String Operations
920
921 static bool isCharacterAllowedInBase(UChar c, int base)
922 {
923     if (c > 0x7F)
924         return false;
925     if (isASCIIDigit(c))
926         return c - '0' < base;
927     if (isASCIIAlpha(c)) {
928         if (base > 36)
929             base = 36;
930         return (c >= 'a' && c < 'a' + base - 10)
931             || (c >= 'A' && c < 'A' + base - 10);
932     }
933     return false;
934 }
935
936 template <typename IntegralType, typename CharType>
937 static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
938 {
939     static const IntegralType integralMax = std::numeric_limits<IntegralType>::max();
940     static const bool isSigned = std::numeric_limits<IntegralType>::is_signed;
941     const IntegralType maxMultiplier = integralMax / base;
942
943     IntegralType value = 0;
944     bool isOk = false;
945     bool isNegative = false;
946
947     if (!data)
948         goto bye;
949
950     // skip leading whitespace
951     while (length && isSpaceOrNewline(*data)) {
952         --length;
953         ++data;
954     }
955
956     if (isSigned && length && *data == '-') {
957         --length;
958         ++data;
959         isNegative = true;
960     } else if (length && *data == '+') {
961         --length;
962         ++data;
963     }
964
965     if (!length || !isCharacterAllowedInBase(*data, base))
966         goto bye;
967
968     while (length && isCharacterAllowedInBase(*data, base)) {
969         --length;
970         IntegralType digitValue;
971         CharType c = *data;
972         if (isASCIIDigit(c))
973             digitValue = c - '0';
974         else if (c >= 'a')
975             digitValue = c - 'a' + 10;
976         else
977             digitValue = c - 'A' + 10;
978
979         if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative))
980             goto bye;
981
982         value = base * value + digitValue;
983         ++data;
984     }
985
986 #if COMPILER(MSVC)
987 #pragma warning(push, 0)
988 #pragma warning(disable:4146)
989 #endif
990
991     if (isNegative)
992         value = -value;
993
994 #if COMPILER(MSVC)
995 #pragma warning(pop)
996 #endif
997
998     // skip trailing space
999     while (length && isSpaceOrNewline(*data)) {
1000         --length;
1001         ++data;
1002     }
1003
1004     if (!length)
1005         isOk = true;
1006 bye:
1007     if (ok)
1008         *ok = isOk;
1009     return isOk ? value : 0;
1010 }
1011
1012 template <typename CharType>
1013 static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length)
1014 {
1015     size_t i = 0;
1016
1017     // Allow leading spaces.
1018     for (; i != length; ++i) {
1019         if (!isSpaceOrNewline(data[i]))
1020             break;
1021     }
1022     
1023     // Allow sign.
1024     if (i != length && (data[i] == '+' || data[i] == '-'))
1025         ++i;
1026     
1027     // Allow digits.
1028     for (; i != length; ++i) {
1029         if (!isASCIIDigit(data[i]))
1030             break;
1031     }
1032
1033     return i;
1034 }
1035
1036 int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base)
1037 {
1038     return toIntegralType<int, LChar>(data, length, ok, base);
1039 }
1040
1041 int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
1042 {
1043     return toIntegralType<int, UChar>(data, length, ok, base);
1044 }
1045
1046 unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base)
1047 {
1048     return toIntegralType<unsigned, LChar>(data, length, ok, base);
1049 }
1050
1051 unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
1052 {
1053     return toIntegralType<unsigned, UChar>(data, length, ok, base);
1054 }
1055
1056 int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1057 {
1058     return toIntegralType<int64_t, LChar>(data, length, ok, base);
1059 }
1060
1061 int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1062 {
1063     return toIntegralType<int64_t, UChar>(data, length, ok, base);
1064 }
1065
1066 uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base)
1067 {
1068     return toIntegralType<uint64_t, LChar>(data, length, ok, base);
1069 }
1070
1071 uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
1072 {
1073     return toIntegralType<uint64_t, UChar>(data, length, ok, base);
1074 }
1075
1076 intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base)
1077 {
1078     return toIntegralType<intptr_t, LChar>(data, length, ok, base);
1079 }
1080
1081 intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base)
1082 {
1083     return toIntegralType<intptr_t, UChar>(data, length, ok, base);
1084 }
1085
1086 int charactersToInt(const LChar* data, size_t length, bool* ok)
1087 {
1088     return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1089 }
1090
1091 int charactersToInt(const UChar* data, size_t length, bool* ok)
1092 {
1093     return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
1094 }
1095
1096 unsigned charactersToUInt(const LChar* data, size_t length, bool* ok)
1097 {
1098     return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1099 }
1100
1101 unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
1102 {
1103     return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1104 }
1105
1106 int64_t charactersToInt64(const LChar* data, size_t length, bool* ok)
1107 {
1108     return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1109 }
1110
1111 int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
1112 {
1113     return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1114 }
1115
1116 uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok)
1117 {
1118     return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1119 }
1120
1121 uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
1122 {
1123     return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1124 }
1125
1126 intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok)
1127 {
1128     return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
1129 }
1130
1131 intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok)
1132 {
1133     return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
1134 }
1135
1136 enum TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk };
1137
1138 template <typename CharType, TrailingJunkPolicy policy>
1139 static inline double toDoubleType(const CharType* data, size_t length, bool* ok, size_t& parsedLength)
1140 {
1141     size_t leadingSpacesLength = 0;
1142     while (leadingSpacesLength < length && isASCIISpace(data[leadingSpacesLength]))
1143         ++leadingSpacesLength;
1144
1145     double number = parseDouble(data + leadingSpacesLength, length - leadingSpacesLength, parsedLength);
1146     if (!parsedLength) {
1147         if (ok)
1148             *ok = false;
1149         return 0.0;
1150     }
1151
1152     parsedLength += leadingSpacesLength;
1153     if (ok)
1154         *ok = policy == AllowTrailingJunk || parsedLength == length;
1155     return number;
1156 }
1157
1158 double charactersToDouble(const LChar* data, size_t length, bool* ok)
1159 {
1160     size_t parsedLength;
1161     return toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1162 }
1163
1164 double charactersToDouble(const UChar* data, size_t length, bool* ok)
1165 {
1166     size_t parsedLength;
1167     return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
1168 }
1169
1170 float charactersToFloat(const LChar* data, size_t length, bool* ok)
1171 {
1172     // FIXME: This will return ok even when the string fits into a double but not a float.
1173     size_t parsedLength;
1174     return static_cast<float>(toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1175 }
1176
1177 float charactersToFloat(const UChar* data, size_t length, bool* ok)
1178 {
1179     // FIXME: This will return ok even when the string fits into a double but not a float.
1180     size_t parsedLength;
1181     return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
1182 }
1183
1184 float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength)
1185 {
1186     // FIXME: This will return ok even when the string fits into a double but not a float.
1187     return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1188 }
1189
1190 float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength)
1191 {
1192     // FIXME: This will return ok even when the string fits into a double but not a float.
1193     return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength));
1194 }
1195
1196 const String& emptyString()
1197 {
1198     static NeverDestroyed<String> emptyString(StringImpl::empty());
1199
1200     return emptyString;
1201 }
1202
1203 } // namespace WTF
1204
1205 #ifndef NDEBUG
1206 // For use in the debugger
1207 String* string(const char*);
1208 Vector<char> asciiDebug(StringImpl* impl);
1209 Vector<char> asciiDebug(String& string);
1210
1211 void String::show() const
1212 {
1213     dataLogF("%s\n", asciiDebug(impl()).data());
1214 }
1215
1216 String* string(const char* s)
1217 {
1218     // leaks memory!
1219     return new String(s);
1220 }
1221
1222 Vector<char> asciiDebug(StringImpl* impl)
1223 {
1224     if (!impl)
1225         return asciiDebug(String(ASCIILiteral("[null]")).impl());
1226
1227     Vector<char> buffer;
1228     for (unsigned i = 0; i < impl->length(); ++i) {
1229         UChar ch = (*impl)[i];
1230         if (isASCIIPrintable(ch)) {
1231             if (ch == '\\')
1232                 buffer.append(ch);
1233             buffer.append(ch);
1234         } else {
1235             buffer.append('\\');
1236             buffer.append('u');
1237             appendUnsignedAsHexFixedSize(ch, buffer, 4);
1238         }
1239     }
1240     buffer.append('\0');
1241     return buffer;
1242 }
1243
1244 Vector<char> asciiDebug(String& string)
1245 {
1246     return asciiDebug(string.impl());
1247 }
1248
1249 #endif