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