Changeset 53320 in webkit


Ignore:
Timestamp:
Jan 14, 2010 10:43:21 PM (14 years ago)
Author:
barraclough@apple.com
Message:

JavaScriptCore: Make naming & behaviour of UString[Impl] methods more consistent.
​https://bugs.webkit.org/show_bug.cgi?id=33702

Reviewed by Sam Weinig.

UString::create() creates a copy of the UChar* passed, but UStringImpl::create() assumes
that it should assume ownership of the provided buffer (with UString::createNonCopying()
and UStringImpl::createCopying() providing the alternate behaviours). Unify on create()
taking a copy of the provided buffer. For non-copying cases, use the name 'adopt', and
make this method take a Vector<UChar>&. For cases where non-copying construction was being
used, other than from a Vector<UChar>, change the code to allocate the storage along with
the UStringImpl using UStringImpl::createUninitialized(). (The adopt() method also more
closely matches that of WebCore::StringImpl).

Also, UString::createUninitialized() and UStringImpl::createUninitialized() have incompatible
behaviours, in that the UString form sets the provided UChar* to a null or non-null value to
indicate success or failure, but UStringImpl uses the returned PassRefPtr<UStringImpl> to
indicate when allocation has failed (potentially leaving the output Char* uninitialized).
This is also incompatible with WebCore::StringImpl's behaviour, in that
StringImpl::createUninitialized() will CRASH() if unable to allocate. Some uses of
createUninitialized() in JSC are unsafe, since they do not test the result for null.
UStringImpl's indication is preferable, since we may want a successful call to set the result
buffer to 0 (specifically, StringImpl returns 0 for the buffer where createUninitialized()
returns the empty string, which seems reasonable to catch bugs early). UString's method
cannot support UStringImpl's behaviour directly, since it returns an object rather than a
pointer.

  • remove UString::createUninitialized(), replace with calls to UStringImpl::createUninitialized()
  • create a UStringImpl::tryCreateUninitialized() form UStringImpl::createUninitialized(), with current behaviour, make createUninitialized() crash on failure to allocate.
  • make cases in JSC that do not check the result call createUninitialized(), and cases that do check call tryCreateUninitialized().

Rename computedHash() to existingHash(), to bring this in line wih WebCore::StringImpl.

  • API/JSClassRef.cpp:

(OpaqueJSClassContextData::OpaqueJSClassContextData):

(JSC::arrayProtoFuncToString):

  • runtime/Identifier.cpp:

(JSC::CStringTranslator::translate):
(JSC::UCharBufferTranslator::translate):

  • runtime/JSString.cpp:

(JSC::JSString::resolveRope):

  • runtime/Lookup.cpp:

(JSC::HashTable::createTable):

  • runtime/Lookup.h:

(JSC::HashTable::entry):

  • runtime/StringBuilder.h:

(JSC::StringBuilder::release):

  • runtime/StringConstructor.cpp:

(JSC::stringFromCharCodeSlowCase):

  • runtime/StringPrototype.cpp:

(JSC::substituteBackreferencesSlow):
(JSC::stringProtoFuncToLowerCase):
(JSC::stringProtoFuncToUpperCase):
(JSC::stringProtoFuncFontsize):
(JSC::stringProtoFuncLink):

  • runtime/Structure.cpp:

(JSC::Structure::despecifyDictionaryFunction):
(JSC::Structure::get):
(JSC::Structure::despecifyFunction):
(JSC::Structure::put):
(JSC::Structure::remove):
(JSC::Structure::insertIntoPropertyMapHashTable):
(JSC::Structure::checkConsistency):

  • runtime/Structure.h:

(JSC::Structure::get):

  • runtime/StructureTransitionTable.h:

(JSC::StructureTransitionTableHash::hash):

  • runtime/UString.cpp:

(JSC::createRep):
(JSC::UString::UString):
(JSC::UString::spliceSubstringsWithSeparators):
(JSC::UString::replaceRange):
(JSC::UString::operator=):

  • runtime/UString.h:

(JSC::UString::adopt):
(JSC::IdentifierRepHash::hash):
(JSC::makeString):

  • runtime/UStringImpl.h:

(JSC::UStringImpl::adopt):
(JSC::UStringImpl::create):
(JSC::UStringImpl::createUninitialized):
(JSC::UStringImpl::tryCreateUninitialized):
(JSC::UStringImpl::existingHash):

WebCore: Rubber stamped by Sam Weinig.

Make naming & behaviour of UString[Impl] methods more consistent.
​https://bugs.webkit.org/show_bug.cgi?id=33702

WebCore change reflecting UString method name change computedHash() -> existingHash().

  • platform/text/AtomicString.cpp:

(WebCore::AtomicString::add):
(WebCore::AtomicString::find):

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/API/JSClassRef.cpp

    r52978 r53320  
    153153            // Use a local variable here to sidestep an RVCT compiler bug.
    154154            StaticValueEntry* entry = new StaticValueEntry(it->second->getProperty, it->second->setProperty, it->second->attributes);
    155             staticValues->add(UString::Rep::createCopying(it->first->data(), it->first->size()), entry);
     155            staticValues->add(UString::Rep::create(it->first->data(), it->first->size()), entry);
    156156
    157157        }
    … …  
    168168            // Use a local variable here to sidestep an RVCT compiler bug.
    169169            StaticFunctionEntry* entry = new StaticFunctionEntry(it->second->callAsFunction, it->second->attributes);
    170             staticFunctions->add(UString::Rep::createCopying(it->first->data(), it->first->size()), entry);
     170            staticFunctions->add(UString::Rep::create(it->first->data(), it->first->size()), entry);
    171171        }
    172172           

  • trunk/JavaScriptCore/ChangeLog

    r53239 r53320  
     12010-01-14  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Reviewed by Sam Weinig.
     4
     5        Make naming & behaviour of UString[Impl] methods more consistent.
     6        https://bugs.webkit.org/show_bug.cgi?id=33702
     7
     8        UString::create() creates a copy of the UChar* passed, but UStringImpl::create() assumes
     9        that it should assume ownership of the provided buffer (with UString::createNonCopying()
     10        and UStringImpl::createCopying() providing the alternate behaviours).  Unify on create()
     11        taking a copy of the provided buffer.  For non-copying cases, use the name 'adopt', and
     12        make this method take a Vector<UChar>&.  For cases where non-copying construction was being
     13        used, other than from a Vector<UChar>, change the code to allocate the storage along with
     14        the UStringImpl using UStringImpl::createUninitialized().  (The adopt() method also more
     15        closely matches that of WebCore::StringImpl).
     16
     17        Also, UString::createUninitialized() and UStringImpl::createUninitialized() have incompatible
     18        behaviours, in that the UString form sets the provided UChar* to a null or non-null value to
     19        indicate success or failure, but UStringImpl uses the returned PassRefPtr<UStringImpl> to
     20        indicate when allocation has failed (potentially leaving the output Char* uninitialized).
     21        This is also incompatible with WebCore::StringImpl's behaviour, in that
     22        StringImpl::createUninitialized() will CRASH() if unable to allocate.  Some uses of
     23        createUninitialized() in JSC are unsafe, since they do not test the result for null.
     24        UStringImpl's indication is preferable, since we may want a successful call to set the result
     25        buffer to 0 (specifically, StringImpl returns 0 for the buffer where createUninitialized()
     26        returns the empty string, which seems reasonable to catch bugs early).  UString's method
     27        cannot support UStringImpl's behaviour directly, since it returns an object rather than a
     28        pointer.
     29            - remove UString::createUninitialized(), replace with calls to UStringImpl::createUninitialized()
     30            - create a UStringImpl::tryCreateUninitialized() form UStringImpl::createUninitialized(),
     31              with current behaviour, make createUninitialized() crash on failure to allocate.
     32            - make cases in JSC that do not check the result call createUninitialized(), and cases that do
     33              check call tryCreateUninitialized().
     34
     35        Rename computedHash() to existingHash(), to bring this in line wih WebCore::StringImpl.
     36
     37        * API/JSClassRef.cpp:
     38        (OpaqueJSClassContextData::OpaqueJSClassContextData):
     39        * JavaScriptCore.exp:
     40        * runtime/ArrayPrototype.cpp:
     41        (JSC::arrayProtoFuncToString):
     42        * runtime/Identifier.cpp:
     43        (JSC::CStringTranslator::translate):
     44        (JSC::UCharBufferTranslator::translate):
     45        * runtime/JSString.cpp:
     46        (JSC::JSString::resolveRope):
     47        * runtime/Lookup.cpp:
     48        (JSC::HashTable::createTable):
     49        * runtime/Lookup.h:
     50        (JSC::HashTable::entry):
     51        * runtime/StringBuilder.h:
     52        (JSC::StringBuilder::release):
     53        * runtime/StringConstructor.cpp:
     54        (JSC::stringFromCharCodeSlowCase):
     55        * runtime/StringPrototype.cpp:
     56        (JSC::substituteBackreferencesSlow):
     57        (JSC::stringProtoFuncToLowerCase):
     58        (JSC::stringProtoFuncToUpperCase):
     59        (JSC::stringProtoFuncFontsize):
     60        (JSC::stringProtoFuncLink):
     61        * runtime/Structure.cpp:
     62        (JSC::Structure::despecifyDictionaryFunction):
     63        (JSC::Structure::get):
     64        (JSC::Structure::despecifyFunction):
     65        (JSC::Structure::put):
     66        (JSC::Structure::remove):
     67        (JSC::Structure::insertIntoPropertyMapHashTable):
     68        (JSC::Structure::checkConsistency):
     69        * runtime/Structure.h:
     70        (JSC::Structure::get):
     71        * runtime/StructureTransitionTable.h:
     72        (JSC::StructureTransitionTableHash::hash):
     73        * runtime/UString.cpp:
     74        (JSC::createRep):
     75        (JSC::UString::UString):
     76        (JSC::UString::spliceSubstringsWithSeparators):
     77        (JSC::UString::replaceRange):
     78        (JSC::UString::operator=):
     79        * runtime/UString.h:
     80        (JSC::UString::adopt):
     81        (JSC::IdentifierRepHash::hash):
     82        (JSC::makeString):
     83        * runtime/UStringImpl.h:
     84        (JSC::UStringImpl::adopt):
     85        (JSC::UStringImpl::create):
     86        (JSC::UStringImpl::createUninitialized):
     87        (JSC::UStringImpl::tryCreateUninitialized):
     88        (JSC::UStringImpl::existingHash):
     89
    1902010-01-13  Kent Hansen  <kent.hansen@nokia.com>
    291

  • trunk/JavaScriptCore/JavaScriptCore.exp

    r53221 r53320  
    106106__ZN3JSC11UStringImpl12sharedBufferEv
    107107__ZN3JSC11UStringImpl6s_nullE
     108__ZN3JSC11UStringImpl7s_emptyE
    108109__ZN3JSC11UStringImplD1Ev
    109110__ZN3JSC11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE
    … …  
    233234__ZN3JSC7Profile7excludeEPKNS_11ProfileNodeE
    234235__ZN3JSC7Profile7forEachEMNS_11ProfileNodeEFvvE
    235 __ZN3JSC7UString16createNonCopyingEPti
    236236__ZN3JSC7UString4fromEd
    237237__ZN3JSC7UString4fromEi

  • trunk/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r53225 r53320  
    7777    ?createInterruptedExecutionException@JSC@@YA?AVJSValue@1@PAVJSGlobalData@1@@Z
    7878    ?createLeaked@JSGlobalData@JSC@@SA?AV?$PassRefPtr@VJSGlobalData@JSC@@@WTF@@XZ
    79     ?createNonCopying@UString@JSC@@SA?AV12@PA_WH@Z
    8079    ?createSingleCharacterString@SmallStrings@JSC@@AAEXPAVJSGlobalData@2@E@Z
    8180    ?createStackOverflowError@JSC@@YA?AVJSValue@1@PAVExecState@1@@Z

  • trunk/JavaScriptCore/runtime/ArrayPrototype.cpp

    r52346 r53320  
    205205    }
    206206    ASSERT(buffer.size() == totalSize);
    207     unsigned finalSize = buffer.size();
    208     return jsString(exec, UString::createNonCopying(buffer.releaseBuffer(), finalSize));
     207    return jsString(exec, UString::adopt(buffer));
    209208}
    210209

  • trunk/JavaScriptCore/runtime/Identifier.cpp

    r53151 r53320  
    113113    {
    114114        size_t length = strlen(c);
    115         UChar* d = static_cast<UChar*>(fastMalloc(sizeof(UChar) * length));
     115        UChar* d;
     116        UString::Rep* r = UString::Rep::createUninitialized(length, d).releaseRef();
    116117        for (size_t i = 0; i != length; i++)
    117118            d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
    118        
    119         UString::Rep* r = UString::Rep::create(d, static_cast<int>(length)).releaseRef();
    120119        r->setHash(hash);
    121 
    122120        location = r;
    123121    }
    … …  
    178176    static void translate(UString::Rep*& location, const UCharBuffer& buf, unsigned hash)
    179177    {
    180         UChar* d = static_cast<UChar*>(fastMalloc(sizeof(UChar) * buf.length));
     178        UChar* d;
     179        UString::Rep* r = UString::Rep::createUninitialized(buf.length, d).releaseRef();
    181180        for (unsigned i = 0; i != buf.length; i++)
    182181            d[i] = buf.s[i];
    183        
    184         UString::Rep* r = UString::Rep::create(d, buf.length).releaseRef();
    185182        r->setHash(hash);
    186        
    187183        location = r;
    188184    }

  • trunk/JavaScriptCore/runtime/JSString.cpp

    r52463 r53320  
    9797    // Allocate the buffer to hold the final string, position initially points to the end.
    9898    UChar* buffer;
    99     m_value = UString::createUninitialized(m_stringLength, buffer);
    100     if (!buffer) {
     99    if (PassRefPtr<UStringImpl> newImpl = UStringImpl::tryCreateUninitialized(m_stringLength, buffer))
     100        m_value = newImpl;
     101    else {
    101102        for (unsigned i = 0; i < m_ropeLength; ++i)
    102103            m_fibers[i].deref();

  • trunk/JavaScriptCore/runtime/Lookup.cpp

    r44224 r53320  
    3535    for (int i = 0; values[i].key; ++i) {
    3636        UString::Rep* identifier = Identifier::add(globalData, values[i].key).releaseRef();
    37         int hashIndex = identifier->computedHash() & compactHashSizeMask;
     37        int hashIndex = identifier->existingHash() & compactHashSizeMask;
    3838        HashEntry* entry = &entries[hashIndex];
    3939

  • trunk/JavaScriptCore/runtime/Lookup.h

    r48005 r53320  
    145145            ASSERT(table);
    146146
    147             const HashEntry* entry = &table[identifier.ustring().rep()->computedHash() & compactHashSizeMask];
     147            const HashEntry* entry = &table[identifier.ustring().rep()->existingHash() & compactHashSizeMask];
    148148
    149149            if (!entry->key())

  • trunk/JavaScriptCore/runtime/StringBuilder.h

    r52346 r53320  
    7070    {
    7171        buffer.shrinkToFit();
    72         size_t length = buffer.size();
    73         return UString::createNonCopying(buffer.releaseBuffer(), length);
     72        return UString::adopt(buffer);
    7473    }
    7574

  • trunk/JavaScriptCore/runtime/StringConstructor.cpp

    r52346 r53320  
    3131static NEVER_INLINE JSValue stringFromCharCodeSlowCase(ExecState* exec, const ArgList& args)
    3232{
    33     UChar* buf = static_cast<UChar*>(fastMalloc(args.size() * sizeof(UChar)));
    34     UChar* p = buf;
    35     ArgList::const_iterator end = args.end();
    36     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
    37         *p++ = static_cast<UChar>((*it).toUInt32(exec));
    38     return jsString(exec, UString::createNonCopying(buf, p - buf));
     33    unsigned length = args.size();
     34    UChar* buf;
     35    PassRefPtr<UStringImpl> impl = UStringImpl::createUninitialized(length, buf);
     36    for (unsigned i = 0; i < length; ++i)
     37        buf[i] = static_cast<UChar>(args.at(i).toUInt32(exec));
     38    return jsString(exec, impl);
    3939}
    4040

  • trunk/JavaScriptCore/runtime/StringPrototype.cpp

    r52791 r53320  
    212212
    213213    substitutedReplacement.shrinkToFit();
    214     unsigned size = substitutedReplacement.size();
    215     return UString::createNonCopying(substitutedReplacement.releaseBuffer(), size);
     214    return UString::adopt(substitutedReplacement);
    216215}
    217216
    … …  
    723722    }
    724723    if (!(ored & ~0x7f))
    725         return jsString(exec, UString::createNonCopying(buffer.releaseBuffer(), sSize));
     724        return jsString(exec, UString::adopt(buffer));
    726725
    727726    bool error;
    … …  
    733732            return sVal;
    734733    }
    735     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
    736         return sVal;
    737     return jsString(exec, UString::createNonCopying(buffer.releaseBuffer(), length));
     734    if (length == sSize) {
     735        if (memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
     736            return sVal;
     737    } else
     738        buffer.resize(length);
     739    return jsString(exec, UString::adopt(buffer));
    738740}
    739741
    … …  
    757759    }
    758760    if (!(ored & ~0x7f))
    759         return jsString(exec, UString::createNonCopying(buffer.releaseBuffer(), sSize));
     761        return jsString(exec, UString::adopt(buffer));
    760762
    761763    bool error;
    … …  
    767769            return sVal;
    768770    }
    769     if (length == sSize && memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
    770         return sVal;
    771     return jsString(exec, UString::createNonCopying(buffer.releaseBuffer(), length));
     771    if (length == sSize) {
     772        if (memcmp(buffer.data(), sData, length * sizeof(UChar)) == 0)
     773            return sVal;
     774    } else
     775        buffer.resize(length);
     776    return jsString(exec, UString::adopt(buffer));
    772777}
    773778
    … …  
    853858        unsigned bufferSize = 22 + stringSize;
    854859        UChar* buffer;
    855         if (!tryFastMalloc(bufferSize * sizeof(UChar)).getValue(buffer))
     860        PassRefPtr<UStringImpl> impl = UStringImpl::tryCreateUninitialized(bufferSize, buffer);
     861        if (!impl)
    856862            return jsUndefined();
    857863        buffer[0] = '<';
    … …  
    878884        buffer[20 + stringSize] = 't';
    879885        buffer[21 + stringSize] = '>';
    880         return jsNontrivialString(exec, UString::createNonCopying(buffer, bufferSize));
     886        return jsNontrivialString(exec, impl);
    881887    }
    882888
    … …  
    901907    unsigned bufferSize = 15 + linkTextSize + stringSize;
    902908    UChar* buffer;
    903     if (!tryFastMalloc(bufferSize * sizeof(UChar)).getValue(buffer))
     909    PassRefPtr<UStringImpl> impl = UStringImpl::tryCreateUninitialized(bufferSize, buffer);
     910    if (!impl)
    904911        return jsUndefined();
    905912    buffer[0] = '<';
    … …  
    920927    buffer[13 + linkTextSize + stringSize] = 'a';
    921928    buffer[14 + linkTextSize + stringSize] = '>';
    922     return jsNontrivialString(exec, UString::createNonCopying(buffer, bufferSize));
     929    return jsNontrivialString(exec, impl);
    923930}
    924931

  • trunk/JavaScriptCore/runtime/Structure.cpp

    r53170 r53320  
    304304    ASSERT(m_propertyTable);
    305305
    306     unsigned i = rep->computedHash();
     306    unsigned i = rep->existingHash();
    307307
    308308#if DUMP_PROPERTYMAP_STATS
    … …  
    322322#endif
    323323
    324     unsigned k = 1 | doubleHash(rep->computedHash());
     324    unsigned k = 1 | doubleHash(rep->existingHash());
    325325
    326326    while (1) {
    … …  
    687687        return notFound;
    688688
    689     unsigned i = rep->computedHash();
     689    unsigned i = rep->existingHash();
    690690
    691691#if DUMP_PROPERTYMAP_STATS
    … …  
    707707#endif
    708708
    709     unsigned k = 1 | doubleHash(rep->computedHash());
     709    unsigned k = 1 | doubleHash(rep->existingHash());
    710710
    711711    while (1) {
    … …  
    738738    UString::Rep* rep = propertyName._ustring.rep();
    739739
    740     unsigned i = rep->computedHash();
     740    unsigned i = rep->existingHash();
    741741
    742742#if DUMP_PROPERTYMAP_STATS
    … …  
    758758#endif
    759759
    760     unsigned k = 1 | doubleHash(rep->computedHash());
     760    unsigned k = 1 | doubleHash(rep->existingHash());
    761761
    762762    while (1) {
    … …  
    807807    // FIXME: Consider a fast case for tables with no deleted sentinels.
    808808
    809     unsigned i = rep->computedHash();
     809    unsigned i = rep->existingHash();
    810810    unsigned k = 0;
    811811    bool foundDeletedElement = false;
    … …  
    830830
    831831        if (k == 0) {
    832             k = 1 | doubleHash(rep->computedHash());
     832            k = 1 | doubleHash(rep->existingHash());
    833833#if DUMP_PROPERTYMAP_STATS
    834834            ++numCollisions;
    … …  
    910910
    911911    // Find the thing to remove.
    912     unsigned i = rep->computedHash();
     912    unsigned i = rep->existingHash();
    913913    unsigned k = 0;
    914914    unsigned entryIndex;
    … …  
    924924
    925925        if (k == 0) {
    926             k = 1 | doubleHash(rep->computedHash());
     926            k = 1 | doubleHash(rep->existingHash());
    927927#if DUMP_PROPERTYMAP_STATS
    928928            ++numCollisions;
    … …  
    968968    ASSERT(m_propertyTable);
    969969
    970     unsigned i = entry.key->computedHash();
     970    unsigned i = entry.key->existingHash();
    971971    unsigned k = 0;
    972972
    … …  
    981981
    982982        if (k == 0) {
    983             k = 1 | doubleHash(entry.key->computedHash());
     983            k = 1 | doubleHash(entry.key->existingHash());
    984984#if DUMP_PROPERTYMAP_STATS
    985985            ++numCollisions;
    … …  
    11791179            continue;
    11801180        ++nonEmptyEntryCount;
    1181         unsigned i = rep->computedHash();
     1181        unsigned i = rep->existingHash();
    11821182        unsigned k = 0;
    11831183        unsigned entryIndex;
    … …  
    11881188                break;
    11891189            if (k == 0)
    1190                 k = 1 | doubleHash(rep->computedHash());
     1190                k = 1 | doubleHash(rep->existingHash());
    11911191            i += k;
    11921192        }

  • trunk/JavaScriptCore/runtime/Structure.h

    r53170 r53320  
    234234        UString::Rep* rep = propertyName._ustring.rep();
    235235
    236         unsigned i = rep->computedHash();
     236        unsigned i = rep->existingHash();
    237237
    238238#if DUMP_PROPERTYMAP_STATS
    … …  
    251251#endif
    252252
    253         unsigned k = 1 | WTF::doubleHash(rep->computedHash());
     253        unsigned k = 1 | WTF::doubleHash(rep->existingHash());
    254254
    255255        while (1) {

  • trunk/JavaScriptCore/runtime/StructureTransitionTable.h

    r48403 r53320  
    4343        static unsigned hash(const Key& p)
    4444        {
    45             return p.first->computedHash();
     45            return p.first->existingHash();
    4646        }
    4747

  • trunk/JavaScriptCore/runtime/UString.cpp

    r52791 r53320  
    171171    size_t length = strlen(c);
    172172    UChar* d;
    173     PassRefPtr<UStringImpl> result = UStringImpl::createUninitialized(length, d);
     173    PassRefPtr<UStringImpl> result = UStringImpl::tryCreateUninitialized(length, d);
    174174    if (!result)
    175175        return &UString::Rep::null();
    … …  
    189189
    190190    UChar* d;
    191     PassRefPtr<UStringImpl> result = UStringImpl::createUninitialized(length, d);
     191    PassRefPtr<UStringImpl> result = UStringImpl::tryCreateUninitialized(length, d);
    192192    if (!result)
    193193        return &UString::Rep::null();
    … …  
    213213        m_rep = &Rep::empty();
    214214    else
    215         m_rep = Rep::createCopying(c, length);
    216 }
    217 
    218 UString UString::createNonCopying(UChar* c, int length)
    219 {
    220     if (length == 0)
    221         return UString(&Rep::empty());
    222     else
    223         return Rep::create(c, length);
     215        m_rep = Rep::create(c, length);
    224216}
    225217
    … …  
    236228
    237229    return UString(buffer.data(), p - buffer.data());
    238 }
    239 
    240 UString UString::createUninitialized(unsigned length, UChar*& output)
    241 {
    242     if (!length) {
    243         output = &sharedEmptyChar;
    244         return UString(&Rep::empty());
    245     }
    246 
    247     if (PassRefPtr<UStringImpl> result = UStringImpl::createUninitialized(length, output))
    248         return result;
    249     output = 0;
    250     return UString();
    251230}
    252231
    … …  
    391370
    392371    UChar* buffer;
    393     if (!UStringImpl::allocChars(totalLength).getValue(buffer))
     372    PassRefPtr<Rep> rep = Rep::tryCreateUninitialized(totalLength, buffer);
     373    if (!rep)
    394374        return null();
    395375
    … …  
    407387    }
    408388
    409     return UString::Rep::create(buffer, totalLength);
     389    return rep;
    410390}
    411391
    … …  
    420400
    421401    UChar* buffer;
    422     if (!UStringImpl::allocChars(totalLength).getValue(buffer))
     402    PassRefPtr<Rep> rep = Rep::tryCreateUninitialized(totalLength, buffer);
     403    if (!rep)
    423404        return null();
    424405
    … …  
    428409    UStringImpl::copyChars(buffer + rangeStart + replacementLength, data() + rangeEnd, size() - rangeEnd);
    429410
    430     return UString::Rep::create(buffer, totalLength);
     411    return rep;
    431412}
    432413
    … …  
    489470
    490471    int l = static_cast<int>(strlen(c));
    491     UChar* d;
    492     if (!UStringImpl::allocChars(l).getValue(d)) {
     472    UChar* d = 0;
     473    m_rep = Rep::tryCreateUninitialized(l, d);
     474    if (m_rep) {
     475        for (int i = 0; i < l; i++)
     476            d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
     477    } else
    493478        makeNull();
    494         return *this;
    495     }
    496     for (int i = 0; i < l; i++)
    497         d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
    498     m_rep = Rep::create(d, l);
    499479
    500480    return *this;

  • trunk/JavaScriptCore/runtime/UString.h

    r52463 r53320  
    104104        }
    105105
    106         static UString createNonCopying(UChar* c, int length);
     106        template<size_t inlineCapacity>
     107        static PassRefPtr<UStringImpl> adopt(Vector<UChar, inlineCapacity>& vector)
     108        {
     109            return Rep::adopt(vector);
     110        }
     111
    107112        static UString createFromUTF8(const char*);
    108         static UString createUninitialized(unsigned length, UChar*& output);
    109113
    110114        static UString from(int);
    … …  
    274278
    275279    struct IdentifierRepHash : PtrHash<RefPtr<JSC::UString::Rep> > {
    276         static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->computedHash(); }
    277         static unsigned hash(JSC::UString::Rep* key) { return key->computedHash(); }
     280        static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->existingHash(); }
     281        static unsigned hash(JSC::UString::Rep* key) { return key->existingHash(); }
    278282    };
    279283
    … …  
    358362        UChar* buffer;
    359363        unsigned length = adapter1.length() + adapter2.length();
    360         UString resultString = UString::createUninitialized(length, buffer);
    361         if (!buffer)
    362             return UString();
    363 
    364         UChar* result = buffer;
    365         adapter1.writeTo(result);
    366         result += adapter1.length();
    367         adapter2.writeTo(result);
    368 
    369         return resultString;
     364        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     365        if (!resultImpl)
     366            return UString();
     367
     368        UChar* result = buffer;
     369        adapter1.writeTo(result);
     370        result += adapter1.length();
     371        adapter2.writeTo(result);
     372
     373        return resultImpl;
    370374    }
    371375
    … …  
    379383        UChar* buffer;
    380384        unsigned length = adapter1.length() + adapter2.length() + adapter3.length();
    381         UString resultString = UString::createUninitialized(length, buffer);
    382         if (!buffer)
     385        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     386        if (!resultImpl)
    383387            return UString();
    384388
    … …  
    390394        adapter3.writeTo(result);
    391395
    392         return resultString;
     396        return resultImpl;
    393397    }
    394398
    … …  
    403407        UChar* buffer;
    404408        unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length();
    405         UString resultString = UString::createUninitialized(length, buffer);
    406         if (!buffer)
     409        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     410        if (!resultImpl)
    407411            return UString();
    408412
    … …  
    416420        adapter4.writeTo(result);
    417421
    418         return resultString;
     422        return resultImpl;
    419423    }
    420424
    … …  
    430434        UChar* buffer;
    431435        unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length();
    432         UString resultString = UString::createUninitialized(length, buffer);
    433         if (!buffer)
     436        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     437        if (!resultImpl)
    434438            return UString();
    435439
    … …  
    445449        adapter5.writeTo(result);
    446450
    447         return resultString;
     451        return resultImpl;
    448452    }
    449453
    … …  
    460464        UChar* buffer;
    461465        unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length();
    462         UString resultString = UString::createUninitialized(length, buffer);
    463         if (!buffer)
     466        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     467        if (!resultImpl)
    464468            return UString();
    465469
    … …  
    477481        adapter6.writeTo(result);
    478482
    479         return resultString;
     483        return resultImpl;
    480484    }
    481485
    … …  
    493497        UChar* buffer;
    494498        unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length() + adapter7.length();
    495         UString resultString = UString::createUninitialized(length, buffer);
    496         if (!buffer)
     499        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     500        if (!resultImpl)
    497501            return UString();
    498502
    … …  
    512516        adapter7.writeTo(result);
    513517
    514         return resultString;
     518        return resultImpl;
    515519    }
    516520
    … …  
    529533        UChar* buffer;
    530534        unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length() + adapter7.length() + adapter8.length();
    531         UString resultString = UString::createUninitialized(length, buffer);
    532         if (!buffer)
     535        PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
     536        if (!resultImpl)
    533537            return UString();
    534538
    … …  
    550554        adapter8.writeTo(result);
    551555
    552         return resultString;
     556        return resultImpl;
    553557    }
    554558

  • trunk/JavaScriptCore/runtime/UStringImpl.h

    r53221 r53320  
    3232#include <wtf/PossiblyNull.h>
    3333#include <wtf/StringHashFunctions.h>
     34#include <wtf/Vector.h>
    3435#include <wtf/unicode/Unicode.h>
    3536
    … …  
    8485class UStringImpl : Noncopyable {
    8586public:
    86     static PassRefPtr<UStringImpl> create(UChar* buffer, int length)
    87     {
    88         return adoptRef(new UStringImpl(buffer, length, BufferOwned));
    89     }
    90 
    91     static PassRefPtr<UStringImpl> createCopying(const UChar* buffer, int length)
     87    template<size_t inlineCapacity>
     88    static PassRefPtr<UStringImpl> adopt(Vector<UChar, inlineCapacity>& vector)
     89    {
     90        if (unsigned length = vector.size())
     91            return adoptRef(new UStringImpl(vector.releaseBuffer(), length, BufferOwned));
     92        return &empty();
     93    }
     94
     95    static PassRefPtr<UStringImpl> create(const UChar* buffer, int length)
    9296    {
    9397        UChar* newBuffer;
    … …  
    112116    static PassRefPtr<UStringImpl> createUninitialized(unsigned length, UChar*& output)
    113117    {
    114         ASSERT(length);
     118        if (!length) {
     119            output = 0;
     120            return &empty();
     121        }
     122
     123        if (length > ((std::numeric_limits<size_t>::max() - sizeof(UStringImpl)) / sizeof(UChar)))
     124            CRASH();
     125        UStringImpl* resultImpl = static_cast<UStringImpl*>(fastMalloc(sizeof(UChar) * length + sizeof(UStringImpl)));
     126        output = reinterpret_cast<UChar*>(resultImpl + 1);
     127        return adoptRef(new(resultImpl) UStringImpl(output, length, BufferInternal));
     128    }
     129
     130    static PassRefPtr<UStringImpl> tryCreateUninitialized(unsigned length, UChar*& output)
     131    {
     132        if (!length) {
     133            output = 0;
     134            return &empty();
     135        }
     136
    115137        if (length > ((std::numeric_limits<size_t>::max() - sizeof(UStringImpl)) / sizeof(UChar)))
    116138            return 0;
    117 
    118139        UStringImpl* resultImpl;
    119140        if (!tryFastMalloc(sizeof(UChar) * length + sizeof(UStringImpl)).getValue(resultImpl))
    120141            return 0;
    121 
    122142        output = reinterpret_cast<UChar*>(resultImpl + 1);
    123143        return adoptRef(new(resultImpl) UStringImpl(output, length, BufferInternal));
    … …  
    139159    }
    140160    unsigned hash() const { if (!m_hash) m_hash = computeHash(data(), m_length); return m_hash; }
    141     unsigned computedHash() const { ASSERT(m_hash); return m_hash; } // fast path for Identifiers
     161    unsigned existingHash() const { ASSERT(m_hash); return m_hash; } // fast path for Identifiers
    142162    void setHash(unsigned hash) { ASSERT(hash == computeHash(data(), m_length)); m_hash = hash; } // fast path for Identifiers
    143163    bool isIdentifier() const { return m_isIdentifier; }

  • trunk/WebCore/ChangeLog

    r53318 r53320  
     12010-01-14  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Rubber stamped by Sam Weinig.
     4
     5        Make naming & behaviour of UString[Impl] methods more consistent.
     6        https://bugs.webkit.org/show_bug.cgi?id=33702
     7
     8        WebCore change reflecting UString method name change computedHash() -> existingHash().
     9
     10        * platform/text/AtomicString.cpp:
     11        (WebCore::AtomicString::add):
     12        (WebCore::AtomicString::find):
     13
    1142010-01-14  Dan Bernstein  <mitz@apple.com>
    215

  • trunk/WebCore/platform/text/AtomicString.cpp

    r52729 r53320  
    253253        return StringImpl::empty();
    254254
    255     HashAndCharacters buffer = { string->computedHash(), string->data(), length };
     255    HashAndCharacters buffer = { string->existingHash(), string->data(), length };
    256256    pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable().add<HashAndCharacters, HashAndCharactersTranslator>(buffer);
    257257    if (!addResult.second)
    … …  
    287287        return static_cast<AtomicStringImpl*>(StringImpl::empty());
    288288
    289     HashAndCharacters buffer = { string->computedHash(), string->data(), length };
     289    HashAndCharacters buffer = { string->existingHash(), string->data(), length };
    290290    HashSet<StringImpl*>::iterator iterator = stringTable().find<HashAndCharacters, HashAndCharactersTranslator>(buffer);
    291291    if (iterator == stringTable().end())
Note: See TracChangeset for help on using the changeset viewer.