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