⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 100195 in webkit


Ignore:
Timestamp:
Nov 14, 2011, 2:42:36 PM (15 years ago)
Author:
msaboff@apple.com
Message:

Towards 8 bit strings - Add 8 bit paths to StringImpl methods
​https://bugs.webkit.org/show_bug.cgi?id=72290

Added 8 bit patchs to StringImpl to number and find methods.

Reviewed by Oliver Hunt.

  • wtf/text/StringImpl.cpp:

(WTF::StringImpl::toIntStrict):
(WTF::StringImpl::toUIntStrict):
(WTF::StringImpl::toInt64Strict):
(WTF::StringImpl::toUInt64Strict):
(WTF::StringImpl::toIntPtrStrict):
(WTF::StringImpl::toInt):
(WTF::StringImpl::toUInt):
(WTF::StringImpl::toInt64):
(WTF::StringImpl::toUInt64):
(WTF::StringImpl::toIntPtr):
(WTF::StringImpl::toDouble):
(WTF::StringImpl::toFloat):
(WTF::StringImpl::find):
(WTF::StringImpl::reverseFind):

  • wtf/text/WTFString.cpp:

(WTF::toIntegralType):
(WTF::lengthOfCharactersAsInteger):
(WTF::charactersToIntStrict):
(WTF::charactersToUIntStrict):
(WTF::charactersToInt64Strict):
(WTF::charactersToUInt64Strict):
(WTF::charactersToIntPtrStrict):
(WTF::charactersToInt):
(WTF::charactersToUInt):
(WTF::charactersToInt64):
(WTF::charactersToUInt64):
(WTF::charactersToIntPtr):
(WTF::toDoubleType):
(WTF::charactersToDouble):
(WTF::charactersToFloat):

  • wtf/text/WTFString.h:

(WTF::find):
(WTF::reverseFind):

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r100180 r100195  
     12011-11-14  Michael Saboff  <msaboff@apple.com>
     2
     3        Towards 8 bit strings - Add 8 bit paths to StringImpl methods
     4        https://bugs.webkit.org/show_bug.cgi?id=72290
     5
     6        Added 8 bit patchs to StringImpl to number and find methods.
     7
     8        Reviewed by Oliver Hunt.
     9
     10        * wtf/text/StringImpl.cpp:
     11        (WTF::StringImpl::toIntStrict):
     12        (WTF::StringImpl::toUIntStrict):
     13        (WTF::StringImpl::toInt64Strict):
     14        (WTF::StringImpl::toUInt64Strict):
     15        (WTF::StringImpl::toIntPtrStrict):
     16        (WTF::StringImpl::toInt):
     17        (WTF::StringImpl::toUInt):
     18        (WTF::StringImpl::toInt64):
     19        (WTF::StringImpl::toUInt64):
     20        (WTF::StringImpl::toIntPtr):
     21        (WTF::StringImpl::toDouble):
     22        (WTF::StringImpl::toFloat):
     23        (WTF::StringImpl::find):
     24        (WTF::StringImpl::reverseFind):
     25        * wtf/text/WTFString.cpp:
     26        (WTF::toIntegralType):
     27        (WTF::lengthOfCharactersAsInteger):
     28        (WTF::charactersToIntStrict):
     29        (WTF::charactersToUIntStrict):
     30        (WTF::charactersToInt64Strict):
     31        (WTF::charactersToUInt64Strict):
     32        (WTF::charactersToIntPtrStrict):
     33        (WTF::charactersToInt):
     34        (WTF::charactersToUInt):
     35        (WTF::charactersToInt64):
     36        (WTF::charactersToUInt64):
     37        (WTF::charactersToIntPtr):
     38        (WTF::toDoubleType):
     39        (WTF::charactersToDouble):
     40        (WTF::charactersToFloat):
     41        * wtf/text/WTFString.h:
     42        (WTF::find):
     43        (WTF::reverseFind):
     44
    1452011-11-14  Vincent Scheib  <scheib@chromium.org>
    246

  • trunk/Source/JavaScriptCore/wtf/text/StringImpl.cpp

    r99072 r100195  
    612612int StringImpl::toIntStrict(bool* ok, int base)
    613613{
     614    if (is8Bit())
     615        return charactersToIntStrict(characters8(), m_length, ok, base);
    614616    return charactersToIntStrict(characters16(), m_length, ok, base);
    615617}
    … …  
    617619unsigned StringImpl::toUIntStrict(bool* ok, int base)
    618620{
     621    if (is8Bit())
     622        return charactersToUIntStrict(characters8(), m_length, ok, base);
    619623    return charactersToUIntStrict(characters16(), m_length, ok, base);
    620624}
    … …  
    622626int64_t StringImpl::toInt64Strict(bool* ok, int base)
    623627{
     628    if (is8Bit())
     629        return charactersToInt64Strict(characters8(), m_length, ok, base);
    624630    return charactersToInt64Strict(characters16(), m_length, ok, base);
    625 
    626631}
    627632
    628633uint64_t StringImpl::toUInt64Strict(bool* ok, int base)
    629634{
     635    if (is8Bit())
     636        return charactersToUInt64Strict(characters8(), m_length, ok, base);
    630637    return charactersToUInt64Strict(characters16(), m_length, ok, base);
    631638}
    … …  
    633640intptr_t StringImpl::toIntPtrStrict(bool* ok, int base)
    634641{
     642    if (is8Bit())
     643        return charactersToIntPtrStrict(characters8(), m_length, ok, base);
    635644    return charactersToIntPtrStrict(characters16(), m_length, ok, base);
    636645}
    … …  
    638647int StringImpl::toInt(bool* ok)
    639648{
     649    if (is8Bit())
     650        return charactersToInt(characters8(), m_length, ok);
    640651    return charactersToInt(characters16(), m_length, ok);
    641652}
    … …  
    643654unsigned StringImpl::toUInt(bool* ok)
    644655{
     656    if (is8Bit())
     657        return charactersToUInt(characters8(), m_length, ok);
    645658    return charactersToUInt(characters16(), m_length, ok);
    646659}
    … …  
    648661int64_t StringImpl::toInt64(bool* ok)
    649662{
     663    if (is8Bit())
     664        return charactersToInt64(characters8(), m_length, ok);
    650665    return charactersToInt64(characters16(), m_length, ok);
    651666}
    … …  
    653668uint64_t StringImpl::toUInt64(bool* ok)
    654669{
     670    if (is8Bit())
     671        return charactersToUInt64(characters8(), m_length, ok);
    655672    return charactersToUInt64(characters16(), m_length, ok);
    656673}
    … …  
    658675intptr_t StringImpl::toIntPtr(bool* ok)
    659676{
     677    if (is8Bit())
     678        return charactersToIntPtr(characters8(), m_length, ok);
    660679    return charactersToIntPtr(characters16(), m_length, ok);
    661 
    662680}
    663681
    664682double StringImpl::toDouble(bool* ok, bool* didReadNumber)
    665683{
     684    if (is8Bit())
     685        return charactersToDouble(characters8(), m_length, ok, didReadNumber);
    666686    return charactersToDouble(characters16(), m_length, ok, didReadNumber);
    667687}
    … …  
    669689float StringImpl::toFloat(bool* ok, bool* didReadNumber)
    670690{
     691    if (is8Bit())
     692        return charactersToFloat(characters8(), m_length, ok, didReadNumber);
    671693    return charactersToFloat(characters16(), m_length, ok, didReadNumber);
    672694}
    … …  
    724746size_t StringImpl::find(UChar c, unsigned start)
    725747{
     748    if (is8Bit())
     749        return WTF::find(characters8(), m_length, c, start);
    726750    return WTF::find(characters16(), m_length, c, start);
    727751}
    … …  
    729753size_t StringImpl::find(CharacterMatchFunctionPtr matchFunction, unsigned start)
    730754{
     755    if (is8Bit())
     756        return WTF::find(characters8(), m_length, matchFunction, start);
    731757    return WTF::find(characters16(), m_length, matchFunction, start);
    732758}
    … …  
    823849
    824850    // Optimization 1: fast case for strings of length 1.
    825     if (matchLength == 1)
    826         return WTF::find(characters16(), length(), matchString->characters16()[0], index);
     851    if (matchLength == 1) {
     852        if (is8Bit() && matchString->is8Bit())
     853            return WTF::find(characters8(), length(), matchString->characters8()[0], index);
     854        return WTF::find(characters(), length(), matchString->characters()[0], index);
     855    }
    827856
    828857    // Check index & matchLength are in range.
    … …  
    892921size_t StringImpl::reverseFind(UChar c, unsigned index)
    893922{
     923    if (is8Bit())
     924        return WTF::reverseFind(characters8(), m_length, c, index);
    894925    return WTF::reverseFind(characters16(), m_length, c, index);
    895926}
    … …  
    905936
    906937    // Optimization 1: fast case for strings of length 1.
    907     if (matchLength == 1)
    908         return WTF::reverseFind(characters16(), length(), matchString->characters()[0], index);
     938    if (matchLength == 1) {
     939        if (is8Bit() && matchString->is8Bit())
     940            return WTF::reverseFind(characters8(), length(), matchString->characters8()[0], index);
     941        return WTF::reverseFind(characters(), length(), matchString->characters()[0], index);
     942    }
    909943
    910944    // Check index & matchLength are in range.

  • trunk/Source/JavaScriptCore/wtf/text/WTFString.cpp

    r98624 r100195  
    789789}
    790790
    791 template <typename IntegralType>
    792 static inline IntegralType toIntegralType(const UChar* data, size_t length, bool* ok, int base)
     791template <typename IntegralType, typename CharType>
     792static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
    793793{
    794794    static const IntegralType integralMax = numeric_limits<IntegralType>::max();
    … …  
    824824        length--;
    825825        IntegralType digitValue;
    826         UChar c = *data;
     826        CharType c = *data;
    827827        if (isASCIIDigit(c))
    828828            digitValue = c - '0';
    … …  
    865865}
    866866
    867 static unsigned lengthOfCharactersAsInteger(const UChar* data, size_t length)
     867template <typename CharType>
     868static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length)
    868869{
    869870    size_t i = 0;
    … …  
    888889}
    889890
     891int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base)
     892{
     893    return toIntegralType<int, LChar>(data, length, ok, base);
     894}
     895
    890896int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base)
    891897{
    892     return toIntegralType<int>(data, length, ok, base);
     898    return toIntegralType<int, UChar>(data, length, ok, base);
     899}
     900
     901unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base)
     902{
     903    return toIntegralType<unsigned, LChar>(data, length, ok, base);
    893904}
    894905
    895906unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base)
    896907{
    897     return toIntegralType<unsigned>(data, length, ok, base);
     908    return toIntegralType<unsigned, UChar>(data, length, ok, base);
     909}
     910
     911int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base)
     912{
     913    return toIntegralType<int64_t, LChar>(data, length, ok, base);
    898914}
    899915
    900916int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base)
    901917{
    902     return toIntegralType<int64_t>(data, length, ok, base);
     918    return toIntegralType<int64_t, UChar>(data, length, ok, base);
     919}
     920
     921uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base)
     922{
     923    return toIntegralType<uint64_t, LChar>(data, length, ok, base);
    903924}
    904925
    905926uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base)
    906927{
    907     return toIntegralType<uint64_t>(data, length, ok, base);
     928    return toIntegralType<uint64_t, UChar>(data, length, ok, base);
     929}
     930
     931intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base)
     932{
     933    return toIntegralType<intptr_t, LChar>(data, length, ok, base);
    908934}
    909935
    910936intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base)
    911937{
    912     return toIntegralType<intptr_t>(data, length, ok, base);
     938    return toIntegralType<intptr_t, UChar>(data, length, ok, base);
     939}
     940
     941int charactersToInt(const LChar* data, size_t length, bool* ok)
     942{
     943    return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
    913944}
    914945
    915946int charactersToInt(const UChar* data, size_t length, bool* ok)
    916947{
    917     return toIntegralType<int>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
     948    return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
     949}
     950
     951unsigned charactersToUInt(const LChar* data, size_t length, bool* ok)
     952{
     953    return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
    918954}
    919955
    920956unsigned charactersToUInt(const UChar* data, size_t length, bool* ok)
    921957{
    922     return toIntegralType<unsigned>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
     958    return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
     959}
     960
     961int64_t charactersToInt64(const LChar* data, size_t length, bool* ok)
     962{
     963    return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
    923964}
    924965
    925966int64_t charactersToInt64(const UChar* data, size_t length, bool* ok)
    926967{
    927     return toIntegralType<int64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
     968    return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
     969}
     970
     971uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok)
     972{
     973    return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
    928974}
    929975
    930976uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok)
    931977{
    932     return toIntegralType<uint64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
     978    return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
     979}
     980
     981intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok)
     982{
     983    return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
    933984}
    934985
    935986intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok)
    936987{
    937     return toIntegralType<intptr_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10);
    938 }
    939 
    940 double charactersToDouble(const UChar* data, size_t length, bool* ok, bool* didReadNumber)
     988    return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
     989}
     990
     991template <typename CharType>
     992static inline double toDoubleType(const CharType* data, size_t length, bool* ok, bool* didReadNumber)
    941993{
    942994    if (!length) {
    … …  
    9621014}
    9631015
     1016double charactersToDouble(const LChar* data, size_t length, bool* ok, bool* didReadNumber)
     1017{
     1018    return toDoubleType<LChar>(data, length, ok, didReadNumber);
     1019}
     1020
     1021double charactersToDouble(const UChar* data, size_t length, bool* ok, bool* didReadNumber)
     1022{
     1023    return toDoubleType<UChar>(data, length, ok, didReadNumber);
     1024}
     1025
     1026float charactersToFloat(const LChar* data, size_t length, bool* ok, bool* didReadNumber)
     1027{
     1028    // FIXME: This will return ok even when the string fits into a double but not a float.
     1029    return static_cast<float>(toDoubleType<LChar>(data, length, ok, didReadNumber));
     1030}
     1031
    9641032float charactersToFloat(const UChar* data, size_t length, bool* ok, bool* didReadNumber)
    9651033{
    9661034    // FIXME: This will return ok even when the string fits into a double but not a float.
    967     return static_cast<float>(charactersToDouble(data, length, ok, didReadNumber));
     1035    return static_cast<float>(toDoubleType<UChar>(data, length, ok, didReadNumber));
    9681036}
    9691037

  • trunk/Source/JavaScriptCore/wtf/text/WTFString.h

    r99128 r100195  
    5656bool charactersAreAllASCII(const UChar*, size_t);
    5757bool charactersAreAllLatin1(const UChar*, size_t);
     58WTF_EXPORT_PRIVATE int charactersToIntStrict(const LChar*, size_t, bool* ok = 0, int base = 10);
    5859WTF_EXPORT_PRIVATE int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
     60WTF_EXPORT_PRIVATE unsigned charactersToUIntStrict(const LChar*, size_t, bool* ok = 0, int base = 10);
    5961WTF_EXPORT_PRIVATE unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
     62int64_t charactersToInt64Strict(const LChar*, size_t, bool* ok = 0, int base = 10);
    6063int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
     64uint64_t charactersToUInt64Strict(const LChar*, size_t, bool* ok = 0, int base = 10);
    6165uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
     66intptr_t charactersToIntPtrStrict(const LChar*, size_t, bool* ok = 0, int base = 10);
    6267intptr_t charactersToIntPtrStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
    6368
     69int charactersToInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6470int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
     71unsigned charactersToUInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6572unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
     73int64_t charactersToInt64(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6674int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
     75uint64_t charactersToUInt64(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6776uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
     77intptr_t charactersToIntPtr(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6878intptr_t charactersToIntPtr(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
    6979
     80WTF_EXPORT_PRIVATE double charactersToDouble(const LChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    7081WTF_EXPORT_PRIVATE double charactersToDouble(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
     82float charactersToFloat(const LChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    7183float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    7284
    … …  
    410422WTF_EXPORT_PRIVATE int codePointCompare(const String&, const String&);
    411423
    412 inline size_t find(const UChar* characters, unsigned length, UChar matchCharacter, unsigned index = 0)
     424inline size_t find(const LChar* characters, unsigned length, LChar matchCharacter, unsigned index = 0)
    413425{
    414426    while (index < length) {
    … …  
    420432}
    421433
    422 inline size_t find(const UChar* characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index = 0)
     434inline size_t find(const UChar* characters, unsigned length, UChar matchCharacter, unsigned index = 0)
     435{
     436    while (index < length) {
     437        if (characters[index] == matchCharacter)
     438            return index;
     439        ++index;
     440    }
     441    return notFound;
     442}
     443
     444inline size_t find(const LChar* characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index = 0)
    423445{
    424446    while (index < length) {
    … …  
    428450    }
    429451    return notFound;
     452}
     453
     454inline size_t find(const UChar* characters, unsigned length, CharacterMatchFunctionPtr matchFunction, unsigned index = 0)
     455{
     456    while (index < length) {
     457        if (matchFunction(characters[index]))
     458            return index;
     459        ++index;
     460    }
     461    return notFound;
     462}
     463
     464inline size_t reverseFind(const LChar* characters, unsigned length, LChar matchCharacter, unsigned index = UINT_MAX)
     465{
     466    if (!length)
     467        return notFound;
     468    if (index >= length)
     469        index = length - 1;
     470    while (characters[index] != matchCharacter) {
     471        if (!index--)
     472            return notFound;
     473    }
     474    return index;
    430475}
    431476
Note: See TracChangeset for help on using the changeset viewer.