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