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