Changeset 65295 in webkit for trunk/JavaScriptCore/runtime


Ignore:
Timestamp:
Aug 12, 2010, 8:58:37 PM (15 years ago)
Author:
[email protected]
Message:

Unify UString::UTF8String() & String::utf8() methods,
remove UString::cost() & make atArrayIndex a free function.

Reviewed by Sam Weinig

JavaScriptCore:

(JSC::constantName):
(JSC::idName):
(JSC::CodeBlock::registerName):
(JSC::regexpName):
(JSC::printGlobalResolveInfo):
(JSC::printStructureStubInfo):
(JSC::CodeBlock::printStructure):
(JSC::CodeBlock::printStructures):

  • jsc.cpp:

(functionPrint):
(functionDebug):
(runInteractive):
(fillBufferWithContentsOfFile):

  • pcre/pcre_exec.cpp:

(Histogram::~Histogram):

  • profiler/CallIdentifier.h:

(JSC::CallIdentifier::c_str):

  • profiler/Profile.cpp:

(JSC::Profile::debugPrintDataSampleStyle):

  • profiler/ProfileGenerator.cpp:

(JSC::ProfileGenerator::willExecute):
(JSC::ProfileGenerator::didExecute):

  • profiler/ProfileNode.cpp:

(JSC::ProfileNode::debugPrintData):
(JSC::ProfileNode::debugPrintDataSampleStyle):

  • runtime/Arguments.cpp:

(JSC::Arguments::getOwnPropertySlot):
(JSC::Arguments::getOwnPropertyDescriptor):
(JSC::Arguments::put):
(JSC::Arguments::deleteProperty):

  • runtime/DateConversion.cpp:

(JSC::parseDate):

  • runtime/Identifier.h:

(JSC::Identifier::toStrictUInt32):

  • runtime/JSArray.cpp:

(JSC::JSArray::getOwnPropertySlot):
(JSC::JSArray::getOwnPropertyDescriptor):
(JSC::JSArray::put):
(JSC::JSArray::deleteProperty):

  • runtime/JSArray.h:

(JSC::toArrayIndex):

  • runtime/JSGlobalObjectFunctions.cpp:

(JSC::encode):
(JSC::parseInt):
(JSC::globalFuncJSCPrint):

  • runtime/JSString.h:

(JSC::RopeBuilder::JSString):

  • runtime/UString.cpp:

(JSC::UString::toDouble):
(JSC::putUTF8Triple):
(JSC::UString::utf8):

  • runtime/UString.h:

(JSC::UString::~UString):
(JSC::UString::isNull):
(JSC::UString::isEmpty):
(JSC::UString::impl):

  • wtf/text/WTFString.cpp:

(WTF::String::utf8):

  • wtf/text/WTFString.h:

(WTF::String::~String):
(WTF::String::swap):
(WTF::String::isNull):
(WTF::String::isEmpty):
(WTF::String::impl):
(WTF::String::length):
(WTF::String::String):
(WTF::String::isHashTableDeletedValue):

WebCore:

  • WebCore.xcodeproj/project.pbxproj:
  • bindings/js/JSDOMWindowCustom.cpp:

(WebCore::JSDOMWindow::getOwnPropertySlot):
(WebCore::JSDOMWindow::getOwnPropertyDescriptor):

  • bridge/NP_jsobject.cpp:

(_NPN_Enumerate):

  • bridge/c/c_utility.cpp:

(JSC::Bindings::convertValueToNPVariant):

  • bridge/jni/JNIBridge.cpp:

(JavaParameter::JavaParameter):
(JavaMethod::JavaMethod):
(JavaMethod::signature):
(JavaMethod::methodID):

  • bridge/jni/JNIBridge.h:

(JSC::Bindings::JavaString::utf8):
(JSC::Bindings::JavaParameter::type):
(JSC::Bindings::JavaMethod::returnType):

  • bridge/jni/jni_jsobject.mm:

(JavaJSObject::call):
(JavaJSObject::eval):
(JavaJSObject::getMember):
(JavaJSObject::setMember):
(JavaJSObject::removeMember):
(JavaJSObject::convertJObjectToValue):

  • bridge/jni/jsc/JNIBridgeJSC.cpp:

(JavaField::JavaField):
(JavaField::valueFromInstance):
(JavaField::setValueToInstance):

  • bridge/jni/jsc/JNIBridgeJSC.h:

(JSC::Bindings::JavaField::type):

  • bridge/jni/jsc/JavaInstanceJSC.cpp:

(JavaInstance::invokeMethod):

  • bridge/jni/jsc/JavaStringJSC.h:

(JSC::Bindings::JavaStringImpl::utf8):

  • bridge/runtime_array.cpp:

(JSC::RuntimeArray::getOwnPropertySlot):
(JSC::RuntimeArray::getOwnPropertyDescriptor):
(JSC::RuntimeArray::put):

WebKit/mac:

  • Plugins/Hosted/NetscapePluginInstanceProxy.mm:

(WebKit::NetscapePluginInstanceProxy::enumerate):

WebKit/wx:

  • WebFrame.cpp:

(wxWebFrame::RunScript):

WebKit2:

  • WebProcess/Plugins/JSNPObject.cpp:

(WebKit::npIdentifierFromIdentifier):

  • WebProcess/Plugins/NPJSObject.cpp:

(WebKit::NPJSObject::enumerate):

  • WebProcess/Plugins/NPRuntimeObjectMap.cpp:

(WebKit::NPRuntimeObjectMap::convertJSValueToNPVariant):

Location:
trunk/JavaScriptCore/runtime
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/runtime/Arguments.cpp

    r65177 r65295  
    158158{
    159159    bool isArrayIndex;
    160     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     160    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    161161    if (isArrayIndex && i < d->numArguments && (!d->deletedArguments || !d->deletedArguments[i])) {
    162162        if (i < d->numParameters) {
    … …  
    183183{
    184184    bool isArrayIndex;
    185     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     185    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    186186    if (isArrayIndex && i < d->numArguments && (!d->deletedArguments || !d->deletedArguments[i])) {
    187187        if (i < d->numParameters) {
    … …  
    234234{
    235235    bool isArrayIndex;
    236     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     236    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    237237    if (isArrayIndex && i < d->numArguments && (!d->deletedArguments || !d->deletedArguments[i])) {
    238238        if (i < d->numParameters)
    … …  
    277277{
    278278    bool isArrayIndex;
    279     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     279    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    280280    if (isArrayIndex && i < d->numArguments) {
    281281        if (!d->deletedArguments) {

  • trunk/JavaScriptCore/runtime/DateConversion.cpp

    r56560 r65295  
    5757    if (date == exec->globalData().cachedDateString)
    5858        return exec->globalData().cachedDateStringValue;
    59     double value = parseDateFromNullTerminatedCharacters(exec, date.UTF8String().data());
     59    double value = parseDateFromNullTerminatedCharacters(exec, date.utf8().data());
    6060    exec->globalData().cachedDateString = date;
    6161    exec->globalData().cachedDateStringValue = value;

  • trunk/JavaScriptCore/runtime/Identifier.h

    r65177 r65295  
    4545        Identifier(JSGlobalData* globalData, const UString& s) : m_string(add(globalData, s.impl())) { }
    4646
    47         // Special constructor for cases where we overwrite an object in place.
    48         Identifier(PlacementNewAdoptType) : m_string(PlacementNewAdopt) { }
    49        
    5047        const UString& ustring() const { return m_string; }
    5148        StringImpl* impl() const { return m_string.impl(); }
    … …  
    6966        uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const { return m_string.toUInt32(ok, tolerateEmptyString); };
    7067        uint32_t toStrictUInt32(bool* ok) const { return m_string.toStrictUInt32(ok); }
    71         unsigned toArrayIndex(bool* ok) const { return m_string.toArrayIndex(ok); }
    7268        double toDouble() const { return m_string.toDouble(); }
    7369       

  • trunk/JavaScriptCore/runtime/JSArray.cpp

    r64937 r65295  
    274274
    275275    bool isArrayIndex;
    276     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     276    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    277277    if (isArrayIndex)
    278278        return JSArray::getOwnPropertySlot(exec, i, slot);
    … …  
    291291   
    292292    bool isArrayIndex;
    293     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     293    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    294294    if (isArrayIndex) {
    295295        if (i >= storage->m_length)
    … …  
    318318{
    319319    bool isArrayIndex;
    320     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     320    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    321321    if (isArrayIndex) {
    322322        put(exec, i, value);
    … …  
    476476{
    477477    bool isArrayIndex;
    478     unsigned i = propertyName.toArrayIndex(&isArrayIndex);
     478    unsigned i = toArrayIndex(propertyName.ustring(), &isArrayIndex);
    479479    if (isArrayIndex)
    480480        return deleteProperty(exec, i);

  • trunk/JavaScriptCore/runtime/JSArray.h

    r65146 r65295  
    262262        }
    263263    }
    264    
     264
     265    // Rule from ECMA 15.2 about what an array index is.
     266    // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
     267    inline unsigned toArrayIndex(const UString& string, bool* ok)
     268    {
     269        unsigned i = string.toStrictUInt32(ok);
     270        if (ok && i >= 0xFFFFFFFFU)
     271            *ok = false;
     272        return i;
     273    }
     274
    265275} // namespace JSC
    266276

  • trunk/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp

    r65177 r65295  
    5454{
    5555    UString str = exec->argument(0).toString(exec);
    56     CString cstr = str.UTF8String(true);
     56    CString cstr = str.utf8(true);
    5757    if (!cstr.data())
    5858        return throwError(exec, createURIError(exec, "String contained an illegal UTF-16 sequence."));
    … …  
    266266    if (number >= mantissaOverflowLowerBound) {
    267267        if (radix == 10)
    268             number = WTF::strtod(s.substr(firstDigitPosition, p - firstDigitPosition).UTF8String().data(), 0);
     268            number = WTF::strtod(s.substr(firstDigitPosition, p - firstDigitPosition).utf8().data(), 0);
    269269        else if (radix == 2 || radix == 4 || radix == 8 || radix == 16 || radix == 32)
    270             number = parseIntOverflow(s.substr(firstDigitPosition, p - firstDigitPosition).UTF8String().data(), p - firstDigitPosition, radix);
     270            number = parseIntOverflow(s.substr(firstDigitPosition, p - firstDigitPosition).utf8().data(), p - firstDigitPosition, radix);
    271271    }
    272272
    … …  
    454454EncodedJSValue JSC_HOST_CALL globalFuncJSCPrint(ExecState* exec)
    455455{
    456     CString string = exec->argument(0).toString(exec).UTF8String();
     456    CString string = exec->argument(0).toString(exec).utf8();
    457457    puts(string.data());
    458458    return JSValue::encode(jsUndefined());

  • trunk/JavaScriptCore/runtime/JSString.h

    r65177 r65295  
    192192        {
    193193            ASSERT(!m_value.isNull());
    194             Heap::heap(this)->reportExtraMemoryCost(value.cost());
     194            Heap::heap(this)->reportExtraMemoryCost(value.impl()->cost());
    195195        }
    196196
    … …  
    309309            m_other.m_finalizerCallback = finalizer;
    310310            m_other.m_finalizerContext = context;
    311             Heap::heap(this)->reportExtraMemoryCost(value.cost());
     311            Heap::heap(this)->reportExtraMemoryCost(value.impl()->cost());
    312312        }
    313313

  • trunk/JavaScriptCore/runtime/UString.cpp

    r65289 r65295  
    258258    }
    259259
    260     // FIXME: If tolerateTrailingJunk is true, then we want to tolerate junk
    261     // after the number, even if it contains invalid UTF-16 sequences. So we
    262     // shouldn't use the UTF8String function, which returns null when it
    263     // encounters invalid UTF-16. Further, we have no need to convert the
    264     // non-ASCII characters to UTF-8, so the UTF8String does quite a bit of
    265     // unnecessary work.
    266 
    267     // FIXME: The space skipping code below skips only ASCII spaces, but callers
    268     // need to skip all StrWhiteSpace. The isStrWhiteSpace function does the
    269     // right thing but requires UChar, not char, for its argument.
    270 
    271260    const UChar* data = this->characters();
    272261    const UChar* end = data + size;
    … …  
    595584}
    596585
    597 CString UString::UTF8String(bool strict) const
    598 {
    599     // Allocate a buffer big enough to hold all the characters.
    600     const unsigned len = length();
    601     Vector<char, 1024> buffer(len * 3);
    602 
    603     // Convert to runs of 8-bit characters.
    604     char* p = buffer.data();
    605     const UChar* d = reinterpret_cast<const UChar*>(&characters()[0]);
    606     ConversionResult result = convertUTF16ToUTF8(&d, d + len, &p, p + buffer.size(), strict);
    607     if (result != conversionOK)
     586// Helper to write a three-byte UTF-8 code point to the buffer, caller must check room is available.
     587static inline void putUTF8Triple(char*& buffer, UChar ch)
     588{
     589    ASSERT(ch >= 0x0800);
     590    *buffer++ = static_cast<char>(((ch >> 12) & 0x0F) | 0xE0);
     591    *buffer++ = static_cast<char>(((ch >> 6) & 0x3F) | 0x80);
     592    *buffer++ = static_cast<char>((ch & 0x3F) | 0x80);
     593}
     594
     595CString UString::utf8(bool strict) const
     596{
     597    unsigned length = this->length();
     598    const UChar* characters = this->characters();
     599
     600    // Allocate a buffer big enough to hold all the characters
     601    // (an individual UTF-16 UChar can only expand to 3 UTF-8 bytes).
     602    // Optimization ideas, if we find this function is hot:
     603    //  * We could speculatively create a CStringBuffer to contain 'length'
     604    //    characters, and resize if necessary (i.e. if the buffer contains
     605    //    non-ascii characters). (Alternatively, scan the buffer first for
     606    //    ascii characters, so we know this will be sufficient).
     607    //  * We could allocate a CStringBuffer with an appropriate size to
     608    //    have a good chance of being able to write the string into the
     609    //    buffer without reallocing (say, 1.5 x length).
     610    Vector<char, 1024> bufferVector(length * 3);
     611
     612    char* buffer = bufferVector.data();
     613    ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict);
     614    ASSERT(result != targetExhausted); // (length * 3) should be sufficient for any conversion
     615
     616    if (result == sourceIllegal) // Only produced from strict conversion.
    608617        return CString();
    609618
    610     return CString(buffer.data(), p - buffer.data());
     619    // If a high surrogate is left unconverted, treat it the same was as an unpaired high surrogate
     620    // would have been handled in the middle of a string with non-strict conversion - which is to say,
     621    // simply encode it to UTF-8.
     622    if (result == sourceExhausted) {
     623        // This should be one unpaired high surrogate.
     624        ASSERT((characters + 1) == (this->characters() + length));
     625        ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF));
     626        // There should be room left, since one UChar hasn't been converted.
     627        ASSERT((buffer + 3) <= (buffer + bufferVector.size()));
     628        putUTF8Triple(buffer, *characters);
     629    }
     630
     631    return CString(bufferVector.data(), buffer - bufferVector.data());
    611632}
    612633

  • trunk/JavaScriptCore/runtime/UString.h

    r65289 r65295  
    3939namespace JSC {
    4040
    41 using WTF::PlacementNewAdoptType;
    42 using WTF::PlacementNewAdopt;
    43 
    4441class UString {
    4542public:
    … …  
    6461    UString(RefPtr<StringImpl> impl) : m_impl(impl) { }
    6562
     63    // Inline the destructor.
     64    ALWAYS_INLINE ~UString() { }
     65
    6666    void swap(UString& o) { m_impl.swap(o.m_impl); }
    6767
    … …  
    6969    static UString adopt(Vector<UChar, inlineCapacity>& vector) { return StringImpl::adopt(vector); }
    7070
    71     static UString number(int);
    72     static UString number(long long);
    73     static UString number(unsigned);
    74     static UString number(long);
    75     static UString number(double);
    76 
    77     // NOTE: This method should only be used for *debugging* purposes as it
    78     // is neither Unicode safe nor free from side effects nor thread-safe.
    79     char* ascii() const;
    80 
    81     /**
    82      * Convert the string to UTF-8, assuming it is UTF-16 encoded.
    83      * In non-strict mode, this function is tolerant of badly formed UTF-16, it
    84      * can create UTF-8 strings that are invalid because they have characters in
    85      * the range U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is
    86      * guaranteed to be otherwise valid.
    87      * In strict mode, error is returned as null CString.
    88      */
    89     CString UTF8String(bool strict = false) const;
     71    bool isNull() const { return !m_impl; }
     72    bool isEmpty() const { return !m_impl || !m_impl->length(); }
     73
     74    StringImpl* impl() const { return m_impl.get(); }
    9075
    9176    unsigned length() const
    … …  
    10388    }
    10489
     90    CString utf8(bool strict = false) const;
     91
    10592    UChar operator[](unsigned index) const
    10693    {
    … …  
    11097    }
    11198
     99    static UString number(int);
     100    static UString number(unsigned);
     101    static UString number(long);
     102    static UString number(long long);
     103    static UString number(double);
     104
     105
     106
    112107    double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
    113108    double toDouble(bool tolerateTrailingJunk) const;
    … …  
    117112    uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const;
    118113    uint32_t toStrictUInt32(bool* ok = 0) const;
    119 
    120     unsigned toArrayIndex(bool* ok = 0) const;
    121114
    122115    static const unsigned NotFound = 0xFFFFFFFFu;
    … …  
    128121    UString substr(unsigned pos = 0, unsigned len = 0xFFFFFFFF) const;
    129122
    130     bool isNull() const { return !m_impl; }
    131     bool isEmpty() const { return !m_impl || !m_impl->length(); }
    132 
    133     StringImpl* impl() const { return m_impl.get(); }
    134 
    135     size_t cost() const
    136     {
    137         if (!m_impl)
    138             return 0;
    139         return m_impl->cost();
    140     }
    141 
    142     ALWAYS_INLINE ~UString() { }
     123    // NOTE: This method should only be used for *debugging* purposes as it
     124    // is neither Unicode safe nor free from side effects nor thread-safe.
     125    char* ascii() const;
     126
    143127private:
    144128    RefPtr<StringImpl> m_impl;
    … …  
    218202}
    219203
    220 // Rule from ECMA 15.2 about what an array index is.
    221 // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
    222 inline unsigned UString::toArrayIndex(bool* ok) const
    223 {
    224     unsigned i = toStrictUInt32(ok);
    225     if (ok && i >= 0xFFFFFFFFU)
    226         *ok = false;
    227     return i;
    228 }
    229 
    230204// We'd rather not do shared substring append for small strings, since
    231205// this runs too much risk of a tiny initial string holding down a
Note: See TracChangeset for help on using the changeset viewer.