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