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