diff options
Diffstat (limited to 'WebCore/platform/text')
48 files changed, 1868 insertions, 1079 deletions
diff --git a/WebCore/platform/text/AtomicString.cpp b/WebCore/platform/text/AtomicString.cpp index c584e6c..dc573e1 100644 --- a/WebCore/platform/text/AtomicString.cpp +++ b/WebCore/platform/text/AtomicString.cpp @@ -20,27 +20,46 @@ #include "config.h" -#ifdef AVOID_STATIC_CONSTRUCTORS +#ifdef SKIP_STATIC_CONSTRUCTORS_ON_GCC #define ATOMICSTRING_HIDE_GLOBALS 1 #endif #include "AtomicString.h" -#include "DeprecatedString.h" #include "StaticConstructors.h" #include "StringHash.h" #include <kjs/identifier.h> +#include <wtf/Threading.h> #include <wtf/HashSet.h> -using KJS::Identifier; -using KJS::UString; +#if ENABLE(WORKERS) +#include <wtf/ThreadSpecific.h> +using namespace WTF; +#endif + +#if USE(JSC) +using JSC::Identifier; +using JSC::UString; +#endif namespace WebCore { -static HashSet<StringImpl*>* stringTable; +#if ENABLE(WORKERS) +static ThreadSpecific<HashSet<StringImpl*> >* staticStringTable; +#else +static HashSet<StringImpl*>* staticStringTable; +#endif -struct CStringTranslator +static inline HashSet<StringImpl*>* stringTable() { +#if ENABLE(WORKERS) + return *staticStringTable; +#else + return staticStringTable; +#endif +} + +struct CStringTranslator { static unsigned hash(const char* c) { return StringImpl::computeHash(c); @@ -74,13 +93,16 @@ bool operator==(const AtomicString& a, const char* b) return CStringTranslator::equal(impl, b); } -StringImpl* AtomicString::add(const char* c) +PassRefPtr<StringImpl> AtomicString::add(const char* c) { if (!c) return 0; if (!*c) return StringImpl::empty(); - return *stringTable->add<const char*, CStringTranslator>(c).first; + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable()->add<const char*, CStringTranslator>(c); + if (!addResult.second) + return *addResult.first; + return adoptRef(*addResult.first); } struct UCharBuffer { @@ -88,6 +110,37 @@ struct UCharBuffer { unsigned length; }; +static inline bool equal(StringImpl* string, const UChar* characters, unsigned length) +{ + if (string->length() != length) + return false; + +#if PLATFORM(ARM) + const UChar* stringCharacters = string->characters(); + for (unsigned i = 0; i != length; ++i) { + if (*stringCharacters++ != *characters++) + return false; + } + return true; +#else + /* Do it 4-bytes-at-a-time on architectures where it's safe */ + + const uint32_t* stringCharacters = reinterpret_cast<const uint32_t*>(string->characters()); + const uint32_t* bufferCharacters = reinterpret_cast<const uint32_t*>(characters); + + unsigned halfLength = length >> 1; + for (unsigned i = 0; i != halfLength; ++i) { + if (*stringCharacters++ != *bufferCharacters++) + return false; + } + + if (length & 1 && *reinterpret_cast<const uint16_t*>(stringCharacters) != *reinterpret_cast<const uint16_t*>(bufferCharacters)) + return false; + + return true; +#endif +} + struct UCharBufferTranslator { static unsigned hash(const UCharBuffer& buf) { @@ -96,37 +149,7 @@ struct UCharBufferTranslator { static bool equal(StringImpl* const& str, const UCharBuffer& buf) { - unsigned strLength = str->length(); - unsigned bufLength = buf.length; - if (strLength != bufLength) - return false; - -#if PLATFORM(ARM) - const UChar* strChars = str->characters(); - const UChar* bufChars = buf.s; - - for (unsigned i = 0; i != strLength; ++i) { - if (*strChars++ != *bufChars++) - return false; - } - return true; -#else - /* Do it 4-bytes-at-a-time on architectures where it's safe */ - const uint32_t* strChars = reinterpret_cast<const uint32_t*>(str->characters()); - const uint32_t* bufChars = reinterpret_cast<const uint32_t*>(buf.s); - - unsigned halfLength = strLength >> 1; - for (unsigned i = 0; i != halfLength; ++i) { - if (*strChars++ != *bufChars++) - return false; - } - - if (strLength & 1 && - *reinterpret_cast<const uint16_t *>(strChars) != *reinterpret_cast<const uint16_t *>(bufChars)) - return false; - - return true; -#endif + return WebCore::equal(str, buf.s, buf.length); } static void translate(StringImpl*& location, const UCharBuffer& buf, unsigned hash) @@ -135,7 +158,31 @@ struct UCharBufferTranslator { } }; -StringImpl* AtomicString::add(const UChar* s, int length) +struct HashAndCharacters { + unsigned hash; + const UChar* characters; + unsigned length; +}; + +struct HashAndCharactersTranslator { + static unsigned hash(const HashAndCharacters& buffer) + { + ASSERT(buffer.hash == StringImpl::computeHash(buffer.characters, buffer.length)); + return buffer.hash; + } + + static bool equal(StringImpl* const& string, const HashAndCharacters& buffer) + { + return WebCore::equal(string, buffer.characters, buffer.length); + } + + static void translate(StringImpl*& location, const HashAndCharacters& buffer, unsigned hash) + { + location = new StringImpl(buffer.characters, buffer.length, hash); + } +}; + +PassRefPtr<StringImpl> AtomicString::add(const UChar* s, int length) { if (!s) return 0; @@ -143,11 +190,14 @@ StringImpl* AtomicString::add(const UChar* s, int length) if (length == 0) return StringImpl::empty(); - UCharBuffer buf = {s, length}; - return *stringTable->add<UCharBuffer, UCharBufferTranslator>(buf).first; + UCharBuffer buf = { s, length }; + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable()->add<UCharBuffer, UCharBufferTranslator>(buf); + if (!addResult.second) + return *addResult.first; + return adoptRef(*addResult.first); } -StringImpl* AtomicString::add(const UChar* s) +PassRefPtr<StringImpl> AtomicString::add(const UChar* s) { if (!s) return 0; @@ -160,10 +210,13 @@ StringImpl* AtomicString::add(const UChar* s) return StringImpl::empty(); UCharBuffer buf = {s, length}; - return *stringTable->add<UCharBuffer, UCharBufferTranslator>(buf).first; + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable()->add<UCharBuffer, UCharBufferTranslator>(buf); + if (!addResult.second) + return *addResult.first; + return adoptRef(*addResult.first); } -StringImpl* AtomicString::add(StringImpl* r) +PassRefPtr<StringImpl> AtomicString::add(StringImpl* r) { if (!r || r->m_inTable) return r; @@ -171,7 +224,7 @@ StringImpl* AtomicString::add(StringImpl* r) if (r->length() == 0) return StringImpl::empty(); - StringImpl* result = *stringTable->add(r).first; + StringImpl* result = *stringTable()->add(r).first; if (result == r) r->m_inTable = true; return result; @@ -179,37 +232,65 @@ StringImpl* AtomicString::add(StringImpl* r) void AtomicString::remove(StringImpl* r) { - stringTable->remove(r); + stringTable()->remove(r); } -StringImpl* AtomicString::add(const KJS::Identifier& str) +#if USE(JSC) +PassRefPtr<StringImpl> AtomicString::add(const JSC::Identifier& identifier) { - return add(reinterpret_cast<const UChar*>(str.data()), str.size()); -} + if (identifier.isNull()) + return 0; -StringImpl* AtomicString::add(const KJS::UString& str) -{ - return add(reinterpret_cast<const UChar*>(str.data()), str.size()); -} + UString::Rep* string = identifier.ustring().rep(); + unsigned length = string->size(); + if (!length) + return StringImpl::empty(); -AtomicString::operator Identifier() const -{ - return m_string; + HashAndCharacters buffer = { string->computedHash(), string->data(), length }; + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable()->add<HashAndCharacters, HashAndCharactersTranslator>(buffer); + if (!addResult.second) + return *addResult.first; + return adoptRef(*addResult.first); } -AtomicString::operator UString() const +PassRefPtr<StringImpl> AtomicString::add(const JSC::UString& ustring) { - return m_string; + if (ustring.isNull()) + return 0; + + UString::Rep* string = ustring.rep(); + unsigned length = string->size(); + if (!length) + return StringImpl::empty(); + + HashAndCharacters buffer = { string->hash(), string->data(), length }; + pair<HashSet<StringImpl*>::iterator, bool> addResult = stringTable()->add<HashAndCharacters, HashAndCharactersTranslator>(buffer); + if (!addResult.second) + return *addResult.first; + return adoptRef(*addResult.first); } +#endif -AtomicString::AtomicString(const DeprecatedString& s) - : m_string(add(reinterpret_cast<const UChar*>(s.unicode()), s.length())) +AtomicStringImpl* AtomicString::find(const JSC::Identifier& identifier) { + if (identifier.isNull()) + return 0; + + UString::Rep* string = identifier.ustring().rep(); + unsigned length = string->size(); + if (!length) + return static_cast<AtomicStringImpl*>(StringImpl::empty()); + + HashAndCharacters buffer = { string->computedHash(), string->data(), length }; + HashSet<StringImpl*>::iterator iterator = stringTable()->find<HashAndCharacters, HashAndCharactersTranslator>(buffer); + if (iterator == stringTable()->end()) + return 0; + return static_cast<AtomicStringImpl*>(*iterator); } -DeprecatedString AtomicString::deprecatedString() const +AtomicString::operator UString() const { - return m_string.deprecatedString(); + return m_string; } DEFINE_GLOBAL(AtomicString, nullAtom) @@ -222,7 +303,14 @@ void AtomicString::init() { static bool initialized; if (!initialized) { - stringTable = new HashSet<StringImpl*>; + // Initialization is not thread safe, so this function must be called from the main thread first. + ASSERT(isMainThread()); + +#if ENABLE(WORKERS) + staticStringTable = new ThreadSpecific<HashSet<StringImpl*> >; +#else + staticStringTable = new HashSet<StringImpl*>; +#endif // Use placement new to initialize the globals. new ((void*)&nullAtom) AtomicString; diff --git a/WebCore/platform/text/AtomicString.h b/WebCore/platform/text/AtomicString.h index 4a0bb5b..ad034d9 100644 --- a/WebCore/platform/text/AtomicString.h +++ b/WebCore/platform/text/AtomicString.h @@ -1,7 +1,5 @@ /* - * This file is part of the DOM implementation for KDE. - * - * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc. + * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -28,6 +26,8 @@ namespace WebCore { +struct AtomicStringHash; + class AtomicString { public: static void init(); @@ -36,17 +36,28 @@ public: AtomicString(const char* s) : m_string(add(s)) { } AtomicString(const UChar* s, int length) : m_string(add(s, length)) { } AtomicString(const UChar* s) : m_string(add(s)) { } - AtomicString(const KJS::UString& s) : m_string(add(s)) { } - AtomicString(const KJS::Identifier& s) : m_string(add(s)) { } +#if USE(JSC) + AtomicString(const JSC::UString& s) : m_string(add(s)) { } + AtomicString(const JSC::Identifier& s) : m_string(add(s)) { } +#endif AtomicString(StringImpl* imp) : m_string(add(imp)) { } AtomicString(AtomicStringImpl* imp) : m_string(imp) { } AtomicString(const String& s) : m_string(add(s.impl())) { } + // Hash table deleted values, which are only constructed and never copied or destroyed. + AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { } + bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); } + +#if USE(JSC) + static AtomicStringImpl* find(const JSC::Identifier&); +#endif + operator const String&() const { return m_string; } - const String& domString() const { return m_string; }; + const String& string() const { return m_string; }; - operator KJS::Identifier() const; - operator KJS::UString() const; +#if USE(JSC) + operator JSC::UString() const; +#endif AtomicStringImpl* impl() const { return static_cast<AtomicStringImpl *>(m_string.impl()); } @@ -57,23 +68,21 @@ public: bool contains(UChar c) const { return m_string.contains(c); } bool contains(const AtomicString& s, bool caseSensitive = true) const - { return m_string.contains(s.domString(), caseSensitive); } + { return m_string.contains(s.string(), caseSensitive); } int find(UChar c, int start = 0) const { return m_string.find(c, start); } int find(const AtomicString& s, int start = 0, bool caseSentitive = true) const - { return m_string.find(s.domString(), start, caseSentitive); } + { return m_string.find(s.string(), start, caseSentitive); } bool startsWith(const AtomicString& s, bool caseSensitive = true) const - { return m_string.startsWith(s.domString(), caseSensitive); } + { return m_string.startsWith(s.string(), caseSensitive); } bool endsWith(const AtomicString& s, bool caseSensitive = true) const - { return m_string.endsWith(s.domString(), caseSensitive); } + { return m_string.endsWith(s.string(), caseSensitive); } int toInt(bool* ok = 0) const { return m_string.toInt(ok); } double toDouble(bool* ok = 0) const { return m_string.toDouble(ok); } float toFloat(bool* ok = 0) const { return m_string.toFloat(ok); } bool percentage(int& p) const { return m_string.percentage(p); } - Length* toLengthArray(int& len) const { return m_string.toLengthArray(len); } - Length* toCoordsArray(int& len) const { return m_string.toCoordsArray(len); } bool isNull() const { return m_string.isNull(); } bool isEmpty() const { return m_string.isEmpty(); } @@ -93,18 +102,17 @@ public: operator QString() const { return m_string; } #endif - AtomicString(const DeprecatedString&); - DeprecatedString deprecatedString() const; - private: String m_string; - static StringImpl* add(const char*); - static StringImpl* add(const UChar*, int length); - static StringImpl* add(const UChar*); - static StringImpl* add(StringImpl*); - static StringImpl* add(const KJS::UString&); - static StringImpl* add(const KJS::Identifier&); + static PassRefPtr<StringImpl> add(const char*); + static PassRefPtr<StringImpl> add(const UChar*, int length); + static PassRefPtr<StringImpl> add(const UChar*); + static PassRefPtr<StringImpl> add(StringImpl*); +#if USE(JSC) + static PassRefPtr<StringImpl> add(const JSC::UString&); + static PassRefPtr<StringImpl> add(const JSC::Identifier&); +#endif }; inline bool operator==(const AtomicString& a, const AtomicString& b) { return a.impl() == b.impl(); } @@ -126,6 +134,7 @@ inline bool equalIgnoringCase(const char* a, const AtomicString& b) { return equ inline bool equalIgnoringCase(const String& a, const AtomicString& b) { return equalIgnoringCase(a.impl(), b.impl()); } // Define external global variables for the commonly used atomic strings. +// These are only usable from the main thread. #ifndef ATOMICSTRING_HIDE_GLOBALS extern const AtomicString nullAtom; extern const AtomicString emptyAtom; @@ -136,4 +145,15 @@ inline bool equalIgnoringCase(const String& a, const AtomicString& b) { return e } // namespace WebCore + +namespace WTF { + + // AtomicStringHash is the default hash for AtomicString + template<typename T> struct DefaultHash; + template<> struct DefaultHash<WebCore::AtomicString> { + typedef WebCore::AtomicStringHash Hash; + }; + +} // namespace WTF + #endif // AtomicString_h diff --git a/WebCore/platform/text/AtomicStringHash.h b/WebCore/platform/text/AtomicStringHash.h new file mode 100644 index 0000000..67a45de --- /dev/null +++ b/WebCore/platform/text/AtomicStringHash.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef AtomicStringHash_h +#define AtomicStringHash_h + +#include "AtomicString.h" +#include <wtf/HashTraits.h> + +namespace WebCore { + + struct AtomicStringHash { + static unsigned hash(const AtomicString& key) + { + return key.impl()->existingHash(); + } + + static bool equal(const AtomicString& a, const AtomicString& b) + { + return a == b; + } + + static const bool safeToCompareToEmptyOrDeleted = false; + }; + +} + +namespace WTF { + + // WebCore::AtomicStringHash is the default hash for AtomicString + template<> struct HashTraits<WebCore::AtomicString> : GenericHashTraits<WebCore::AtomicString> { + static const bool emptyValueIsZero = true; + static void constructDeletedValue(WebCore::AtomicString& slot) { new (&slot) WebCore::AtomicString(HashTableDeletedValue); } + static bool isDeletedValue(const WebCore::AtomicString& slot) { return slot.isHashTableDeletedValue(); } + }; + +} + +#endif diff --git a/WebCore/platform/text/BidiResolver.h b/WebCore/platform/text/BidiResolver.h index d2515a9..ffd3d51 100644 --- a/WebCore/platform/text/BidiResolver.h +++ b/WebCore/platform/text/BidiResolver.h @@ -1,6 +1,6 @@ /* * Copyright (C) 2000 Lars Knoll (knoll@kde.org) - * Copyright (C) 2003, 2004, 2006, 2007 Apple Inc. All right reserved. + * Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc. All right reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -23,7 +23,9 @@ #define BidiResolver_h #include "BidiContext.h" +#include <wtf/Noncopyable.h> #include <wtf/PassRefPtr.h> +#include <wtf/Vector.h> namespace WebCore { @@ -85,6 +87,8 @@ struct BidiCharacterRun { } } + void destroy() { delete this; } + int start() const { return m_start; } int stop() const { return m_stop; } unsigned char level() const { return m_level; } @@ -100,19 +104,24 @@ struct BidiCharacterRun { BidiCharacterRun* m_next; }; -template <class Iterator, class Run> class BidiResolver { +template <class Iterator, class Run> class BidiResolver : public Noncopyable { public : BidiResolver() : m_direction(WTF::Unicode::OtherNeutral) - , m_adjustEmbedding(false) , reachedEndOfLine(false) , emptyRun(true) , m_firstRun(0) , m_lastRun(0) + , m_logicallyLastRun(0) , m_runCount(0) { } + const Iterator& position() const { return current; } + void setPosition(const Iterator& position) { current = position; } + + void increment() { current.increment(); } + BidiContext* context() const { return m_status.context.get(); } void setContext(PassRefPtr<BidiContext> c) { m_status.context = c; } @@ -126,22 +135,27 @@ public : const BidiStatus& status() const { return m_status; } void setStatus(const BidiStatus s) { m_status = s; } - bool adjustEmbedding() const { return m_adjustEmbedding; } - void setAdjustEmbedding(bool adjsutEmbedding) { m_adjustEmbedding = adjsutEmbedding; } - void embed(WTF::Unicode::Direction); - void createBidiRunsForLine(const Iterator& start, const Iterator& end, bool visualOrder = false, bool hardLineBreak = false); + void commitExplicitEmbedding(); + + void createBidiRunsForLine(const Iterator& end, bool visualOrder = false, bool hardLineBreak = false); Run* firstRun() const { return m_firstRun; } Run* lastRun() const { return m_lastRun; } - int runCount() const { return m_runCount; } + Run* logicallyLastRun() const { return m_logicallyLastRun; } + unsigned runCount() const { return m_runCount; } void addRun(Run*); + void prependRun(Run*); + + void moveRunToEnd(Run*); + void moveRunToBeginning(Run*); + void deleteRuns(); protected: void appendRun(); - void reverseRuns(int start, int end); + void reverseRuns(unsigned start, unsigned end); Iterator current; Iterator sor; @@ -149,7 +163,6 @@ protected: Iterator last; BidiStatus m_status; WTF::Unicode::Direction m_direction; - bool m_adjustEmbedding; Iterator endOfLine; bool reachedEndOfLine; Iterator lastBeforeET; @@ -157,25 +170,96 @@ protected: Run* m_firstRun; Run* m_lastRun; - int m_runCount; + Run* m_logicallyLastRun; + unsigned m_runCount; + +private: + void raiseExplicitEmbeddingLevel(WTF::Unicode::Direction from, WTF::Unicode::Direction to); + void lowerExplicitEmbeddingLevel(WTF::Unicode::Direction from); + + Vector<WTF::Unicode::Direction, 8> m_currentExplicitEmbeddingSequence; }; template <class Iterator, class Run> -void BidiResolver<Iterator, Run>::appendRun() +inline void BidiResolver<Iterator, Run>::addRun(Run* run) { - if (emptyRun || eor.atEnd()) - return; - - Run* bidiRun = new Run(sor.offset(), eor.offset() + 1, context(), m_direction); if (!m_firstRun) - m_firstRun = bidiRun; + m_firstRun = run; + else + m_lastRun->m_next = run; + m_lastRun = run; + m_runCount++; +} + +template <class Iterator, class Run> +inline void BidiResolver<Iterator, Run>::prependRun(Run* run) +{ + ASSERT(!run->m_next); + + if (!m_lastRun) + m_lastRun = run; else - m_lastRun->m_next = bidiRun; - m_lastRun = bidiRun; + run->m_next = m_firstRun; + m_firstRun = run; m_runCount++; +} + +template <class Iterator, class Run> +inline void BidiResolver<Iterator, Run>::moveRunToEnd(Run* run) +{ + ASSERT(m_firstRun); + ASSERT(m_lastRun); + ASSERT(run->m_next); + + Run* current = 0; + Run* next = m_firstRun; + while (next != run) { + current = next; + next = current->next(); + } + + if (!current) + m_firstRun = run->next(); + else + current->m_next = run->m_next; + + run->m_next = 0; + m_lastRun->m_next = run; + m_lastRun = run; +} + +template <class Iterator, class Run> +inline void BidiResolver<Iterator, Run>::moveRunToBeginning(Run* run) +{ + ASSERT(m_firstRun); + ASSERT(m_lastRun); + ASSERT(run != m_firstRun); + + Run* current = m_firstRun; + Run* next = current->next(); + while (next != run) { + current = next; + next = current->next(); + } + + current->m_next = run->m_next; + if (run == m_lastRun) + m_lastRun = current; + + run->m_next = m_firstRun; + m_firstRun = run; +} + +template <class Iterator, class Run> +void BidiResolver<Iterator, Run>::appendRun() +{ + if (!emptyRun && !eor.atEnd()) { + addRun(new Run(sor.offset(), eor.offset() + 1, context(), m_direction)); + + eor.increment(); + sor = eor; + } - eor.increment(*this); - sor = eor; m_direction = WTF::Unicode::OtherNeutral; m_status.eor = WTF::Unicode::OtherNeutral; } @@ -185,122 +269,144 @@ void BidiResolver<Iterator, Run>::embed(WTF::Unicode::Direction d) { using namespace WTF::Unicode; - bool b = m_adjustEmbedding; - m_adjustEmbedding = false; - if (d == PopDirectionalFormat) { - BidiContext* c = context()->parent(); - if (c) { - if (!emptyRun && eor != last) { - ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); - // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last - ASSERT(m_status.last == EuropeanNumberSeparator - || m_status.last == EuropeanNumberTerminator - || m_status.last == CommonNumberSeparator - || m_status.last == BoundaryNeutral - || m_status.last == BlockSeparator - || m_status.last == SegmentSeparator - || m_status.last == WhiteSpaceNeutral - || m_status.last == OtherNeutral); - if (m_direction == OtherNeutral) - m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; - if (context()->dir() == LeftToRight) { - // bidi.sor ... bidi.eor ... bidi.last L - if (m_status.eor == EuropeanNumber) { - if (m_status.lastStrong != LeftToRight) { - m_direction = EuropeanNumber; - appendRun(); - } - } else if (m_status.eor == ArabicNumber) { - m_direction = ArabicNumber; - appendRun(); - } else if (m_status.lastStrong != LeftToRight) { - if (context()->dir() == RightToLeft) - m_direction = RightToLeft; - else { - appendRun(); - m_direction = LeftToRight; - } - } - } else if (m_status.eor == EuropeanNumber || m_status.eor == ArabicNumber || m_status.lastStrong == LeftToRight) { + ASSERT(d == PopDirectionalFormat || d == LeftToRightEmbedding || d == LeftToRightOverride || d == RightToLeftEmbedding || d == RightToLeftOverride); + m_currentExplicitEmbeddingSequence.append(d); +} + +template <class Iterator, class Run> +void BidiResolver<Iterator, Run>::lowerExplicitEmbeddingLevel(WTF::Unicode::Direction from) +{ + using namespace WTF::Unicode; + + if (!emptyRun && eor != last) { + ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); + // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last + ASSERT(m_status.last == EuropeanNumberSeparator + || m_status.last == EuropeanNumberTerminator + || m_status.last == CommonNumberSeparator + || m_status.last == BoundaryNeutral + || m_status.last == BlockSeparator + || m_status.last == SegmentSeparator + || m_status.last == WhiteSpaceNeutral + || m_status.last == OtherNeutral); + if (m_direction == OtherNeutral) + m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; + if (from == LeftToRight) { + // bidi.sor ... bidi.eor ... bidi.last L + if (m_status.eor == EuropeanNumber) { + if (m_status.lastStrong != LeftToRight) { + m_direction = EuropeanNumber; appendRun(); - m_direction = RightToLeft; } - eor = last; + } else if (m_status.eor == ArabicNumber) { + m_direction = ArabicNumber; + appendRun(); + } else if (m_status.lastStrong != LeftToRight) { + appendRun(); + m_direction = LeftToRight; } + } else if (m_status.eor == EuropeanNumber || m_status.eor == ArabicNumber || m_status.lastStrong == LeftToRight) { appendRun(); - emptyRun = true; - // sor for the new run is determined by the higher level (rule X10) - setLastDir(context()->dir()); - setLastStrongDir(context()->dir()); - setContext(c); - eor = Iterator(); - } - } else { - Direction runDir; - if (d == RightToLeftEmbedding || d == RightToLeftOverride) - runDir = RightToLeft; - else - runDir = LeftToRight; - bool override = d == LeftToRightOverride || d == RightToLeftOverride; - - unsigned char level = context()->level(); - if (runDir == RightToLeft) { - if (level % 2) // we have an odd level - level += 2; - else - level++; - } else { - if (level % 2) // we have an odd level - level++; - else - level += 2; + m_direction = RightToLeft; } + eor = last; + } + appendRun(); + emptyRun = true; + // sor for the new run is determined by the higher level (rule X10) + setLastDir(from); + setLastStrongDir(from); + eor = Iterator(); +} - if (level < 61) { - if (!emptyRun && eor != last) { - ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); - // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last - ASSERT(m_status.last == EuropeanNumberSeparator - || m_status.last == EuropeanNumberTerminator - || m_status.last == CommonNumberSeparator - || m_status.last == BoundaryNeutral - || m_status.last == BlockSeparator - || m_status.last == SegmentSeparator - || m_status.last == WhiteSpaceNeutral - || m_status.last == OtherNeutral); - if (m_direction == OtherNeutral) - m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; - if (runDir == LeftToRight) { - // bidi.sor ... bidi.eor ... bidi.last L - if (m_status.eor == EuropeanNumber) { - if (m_status.lastStrong != LeftToRight) { - m_direction = EuropeanNumber; - appendRun(); - } - } else if (m_status.eor == ArabicNumber) { - m_direction = ArabicNumber; - appendRun(); - } else if (m_status.lastStrong != LeftToRight && context()->dir() == LeftToRight) { - appendRun(); - m_direction = LeftToRight; - } - } else if (m_status.eor == ArabicNumber - || m_status.eor == EuropeanNumber && (m_status.lastStrong != LeftToRight || context()->dir() == RightToLeft) - || m_status.eor != EuropeanNumber && m_status.lastStrong == LeftToRight && context()->dir() == RightToLeft) { +template <class Iterator, class Run> +void BidiResolver<Iterator, Run>::raiseExplicitEmbeddingLevel(WTF::Unicode::Direction from, WTF::Unicode::Direction to) +{ + using namespace WTF::Unicode; + + if (!emptyRun && eor != last) { + ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); + // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last + ASSERT(m_status.last == EuropeanNumberSeparator + || m_status.last == EuropeanNumberTerminator + || m_status.last == CommonNumberSeparator + || m_status.last == BoundaryNeutral + || m_status.last == BlockSeparator + || m_status.last == SegmentSeparator + || m_status.last == WhiteSpaceNeutral + || m_status.last == OtherNeutral); + if (m_direction == OtherNeutral) + m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; + if (to == LeftToRight) { + // bidi.sor ... bidi.eor ... bidi.last L + if (m_status.eor == EuropeanNumber) { + if (m_status.lastStrong != LeftToRight) { + m_direction = EuropeanNumber; appendRun(); - m_direction = RightToLeft; } - eor = last; + } else if (m_status.eor == ArabicNumber) { + m_direction = ArabicNumber; + appendRun(); + } else if (m_status.lastStrong != LeftToRight && from == LeftToRight) { + appendRun(); + m_direction = LeftToRight; } + } else if (m_status.eor == ArabicNumber + || m_status.eor == EuropeanNumber && (m_status.lastStrong != LeftToRight || from == RightToLeft) + || m_status.eor != EuropeanNumber && m_status.lastStrong == LeftToRight && from == RightToLeft) { appendRun(); - emptyRun = true; - setContext(new BidiContext(level, runDir, override, context())); - setLastDir(runDir); - setLastStrongDir(runDir); - eor = Iterator(); + m_direction = RightToLeft; + } + eor = last; + } + appendRun(); + emptyRun = true; + setLastDir(to); + setLastStrongDir(to); + eor = Iterator(); +} + +template <class Iterator, class Run> +void BidiResolver<Iterator, Run>::commitExplicitEmbedding() +{ + using namespace WTF::Unicode; + + unsigned char fromLevel = context()->level(); + RefPtr<BidiContext> toContext = context(); + + for (size_t i = 0; i < m_currentExplicitEmbeddingSequence.size(); ++i) { + Direction embedding = m_currentExplicitEmbeddingSequence[i]; + if (embedding == PopDirectionalFormat) { + if (BidiContext* parentContext = toContext->parent()) + toContext = parentContext; + } else { + Direction direction = (embedding == RightToLeftEmbedding || embedding == RightToLeftOverride) ? RightToLeft : LeftToRight; + bool override = embedding == LeftToRightOverride || embedding == RightToLeftOverride; + unsigned char level = toContext->level(); + if (direction == RightToLeft) { + // Go to the least greater odd integer + level += 1; + level |= 1; + } else { + // Go to the least greater even integer + level += 2; + level &= ~1; + } + if (level < 61) + toContext = new BidiContext(level, direction, override, toContext.get()); } } - m_adjustEmbedding = b; + + unsigned char toLevel = toContext->level(); + + if (toLevel > fromLevel) + raiseExplicitEmbeddingLevel(fromLevel % 2 ? RightToLeft : LeftToRight, toLevel % 2 ? RightToLeft : LeftToRight); + else if (toLevel < fromLevel) + lowerExplicitEmbeddingLevel(fromLevel % 2 ? RightToLeft : LeftToRight); + + setContext(toContext); + + m_currentExplicitEmbeddingSequence.clear(); } template <class Iterator, class Run> @@ -312,8 +418,8 @@ void BidiResolver<Iterator, Run>::deleteRuns() Run* curr = m_firstRun; while (curr) { - Run* s = curr->m_next; - delete curr; + Run* s = curr->next(); + curr->destroy(); curr = s; } @@ -323,18 +429,18 @@ void BidiResolver<Iterator, Run>::deleteRuns() } template <class Iterator, class Run> -void BidiResolver<Iterator, Run>::reverseRuns(int start, int end) +void BidiResolver<Iterator, Run>::reverseRuns(unsigned start, unsigned end) { if (start >= end) return; - ASSERT(start >= 0 && end < m_runCount); + ASSERT(end < m_runCount); // Get the item before the start of the runs to reverse and put it in // |beforeStart|. |curr| should point to the first run to reverse. Run* curr = m_firstRun; Run* beforeStart = 0; - int i = 0; + unsigned i = 0; while (i < start) { i++; beforeStart = curr; @@ -373,7 +479,7 @@ void BidiResolver<Iterator, Run>::reverseRuns(int start, int end) } template <class Iterator, class Run> -void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, const Iterator& end, bool visualOrder, bool hardLineBreak) +void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, bool visualOrder, bool hardLineBreak) { using namespace WTF::Unicode; @@ -383,7 +489,6 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c eor = Iterator(); - current = start; last = current; bool pastEnd = false; BidiResolver<Iterator, Run> stateAtEnd; @@ -426,6 +531,7 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c case LeftToRightOverride: case PopDirectionalFormat: embed(dirCurrent); + commitExplicitEmbedding(); break; // strong types @@ -684,12 +790,11 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c } appendRun(); } + current = end; m_status = stateAtEnd.m_status; - current = stateAtEnd.current; sor = stateAtEnd.sor; eor = stateAtEnd.eor; last = stateAtEnd.last; - m_adjustEmbedding = stateAtEnd.m_adjustEmbedding; reachedEndOfLine = stateAtEnd.reachedEndOfLine; lastBeforeET = stateAtEnd.lastBeforeET; emptyRun = stateAtEnd.emptyRun; @@ -747,11 +852,10 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c emptyRun = false; } - // this causes the operator ++ to open and close embedding levels as needed - // for the CSS unicode-bidi property - m_adjustEmbedding = true; - current.increment(*this); - m_adjustEmbedding = false; + increment(); + if (!m_currentExplicitEmbeddingSequence.isEmpty()) + commitExplicitEmbedding(); + if (emptyRun && (dirCurrent == RightToLeftEmbedding || dirCurrent == LeftToRightEmbedding || dirCurrent == RightToLeftOverride @@ -766,12 +870,20 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c if (!pastEnd && (current == end || current.atEnd())) { if (emptyRun) break; - stateAtEnd = *this; + stateAtEnd.m_status = m_status; + stateAtEnd.sor = sor; + stateAtEnd.eor = eor; + stateAtEnd.last = last; + stateAtEnd.reachedEndOfLine = reachedEndOfLine; + stateAtEnd.lastBeforeET = lastBeforeET; + stateAtEnd.emptyRun = emptyRun; endOfLine = last; pastEnd = true; } } + m_logicallyLastRun = m_lastRun; + // reorder line according to run structure... // do not reverse for visually ordered web sites if (!visualOrder) { @@ -796,22 +908,22 @@ void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& start, c if (!(levelLow % 2)) levelLow++; - int count = runCount() - 1; + unsigned count = runCount() - 1; while (levelHigh >= levelLow) { - int i = 0; + unsigned i = 0; Run* currRun = firstRun(); while (i < count) { while (i < count && currRun && currRun->m_level < levelHigh) { i++; currRun = currRun->next(); } - int start = i; + unsigned start = i; while (i <= count && currRun && currRun->m_level >= levelHigh) { i++; currRun = currRun->next(); } - int end = i-1; + unsigned end = i - 1; reverseRuns(start, end); } levelHigh--; diff --git a/WebCore/platform/text/CString.cpp b/WebCore/platform/text/CString.cpp index 4300b29..8e68628 100644 --- a/WebCore/platform/text/CString.cpp +++ b/WebCore/platform/text/CString.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2003, 2006 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,7 +26,8 @@ #include "config.h" #include "CString.h" -#include "DeprecatedCString.h" + +using std::min; namespace WebCore { @@ -40,17 +41,12 @@ CString::CString(const char* str, unsigned length) init(str, length); } -CString::CString(const DeprecatedCString& str) -{ - init(str.data(), str.length()); -} - void CString::init(const char* str, unsigned length) { if (!str) return; - m_buffer = new CStringBuffer(length + 1); + m_buffer = CStringBuffer::create(length + 1); memcpy(m_buffer->data(), str, length); m_buffer->data()[length] = '\0'; } @@ -72,16 +68,11 @@ unsigned CString::length() const { return m_buffer ? m_buffer->length() - 1 : 0; } - -DeprecatedCString CString::deprecatedCString() const -{ - return DeprecatedCString(data(), length() + 1); -} CString CString::newUninitialized(size_t length, char*& characterBuffer) { CString result; - result.m_buffer = new CStringBuffer(length + 1); + result.m_buffer = CStringBuffer::create(length + 1); char* bytes = result.m_buffer->data(); bytes[length] = '\0'; characterBuffer = bytes; @@ -95,7 +86,7 @@ void CString::copyBufferIfNeeded() int len = m_buffer->length(); RefPtr<CStringBuffer> m_temp = m_buffer; - m_buffer = new CStringBuffer(len); + m_buffer = CStringBuffer::create(len); memcpy(m_buffer->data(), m_temp->data(), len); } @@ -108,4 +99,17 @@ bool operator==(const CString& a, const CString& b) return !strncmp(a.data(), b.data(), min(a.length(), b.length())); } +PassRefPtr<SharedBuffer> CString::releaseBuffer() +{ + if (!m_buffer) + return 0; + + copyBufferIfNeeded(); + + RefPtr<SharedBuffer> result = m_buffer->releaseBuffer(); + m_buffer = 0; + return result.release(); +} + + } diff --git a/WebCore/platform/text/CString.h b/WebCore/platform/text/CString.h index bd1e06c..09f112f 100644 --- a/WebCore/platform/text/CString.h +++ b/WebCore/platform/text/CString.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2003, 2006 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,23 +26,26 @@ #ifndef CString_h #define CString_h +#include "SharedBuffer.h" + +#include <wtf/PassRefPtr.h> #include <wtf/RefCounted.h> #include <wtf/Vector.h> -using std::min; - namespace WebCore { - class DeprecatedCString; - class CStringBuffer : public RefCounted<CStringBuffer> { public: - CStringBuffer(unsigned length) : m_vector(length) { } + static PassRefPtr<CStringBuffer> create(unsigned length) { return adoptRef(new CStringBuffer(length)); } char* data() { return m_vector.data(); } - unsigned length() const { return m_vector.size(); } + size_t length() const { return m_vector.size(); } + + PassRefPtr<SharedBuffer> releaseBuffer() { return SharedBuffer::adoptVector(m_vector); } private: + CStringBuffer(unsigned length) : m_vector(length) { } + Vector<char> m_vector; }; @@ -60,9 +63,8 @@ namespace WebCore { unsigned length() const; bool isNull() const { return !m_buffer; } - - CString(const DeprecatedCString&); - DeprecatedCString deprecatedCString() const; + + PassRefPtr<SharedBuffer> releaseBuffer(); private: void copyBufferIfNeeded(); @@ -73,6 +75,6 @@ namespace WebCore { bool operator==(const CString& a, const CString& b); inline bool operator!=(const CString& a, const CString& b) { return !(a == b); } -} +} // namespace WebCore #endif // CString_h diff --git a/WebCore/platform/text/CharacterNames.h b/WebCore/platform/text/CharacterNames.h index 5b52479..f589a6c 100644 --- a/WebCore/platform/text/CharacterNames.h +++ b/WebCore/platform/text/CharacterNames.h @@ -39,6 +39,8 @@ namespace WebCore { const UChar bullet = 0x2022; const UChar horizontalEllipsis = 0x2026; const UChar ideographicSpace = 0x3000; + const UChar ideographicComma = 0x3001; + const UChar ideographicFullStop = 0x3002; const UChar leftToRightMark = 0x200E; const UChar leftToRightEmbed = 0x202A; const UChar leftToRightOverride = 0x202D; @@ -46,6 +48,7 @@ namespace WebCore { const UChar noBreakSpace = 0x00A0; const UChar objectReplacementCharacter = 0xFFFC; const UChar popDirectionalFormatting = 0x202C; + const UChar replacementCharacter = 0xFFFD; const UChar rightToLeftMark = 0x200F; const UChar rightToLeftEmbed = 0x202B; const UChar rightToLeftOverride = 0x202E; diff --git a/WebCore/platform/text/ParserUtilities.h b/WebCore/platform/text/ParserUtilities.h new file mode 100644 index 0000000..3105214 --- /dev/null +++ b/WebCore/platform/text/ParserUtilities.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2008 Apple Inc. All Rights Reserved. + * Copyright (C) 2002, 2003 The Karbon Developers + * Copyright (C) 2006, 2007 Rob Buis <buis@kde.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef ParserUtilities_h +#define ParserUtilities_h + +#include "PlatformString.h" + +namespace WebCore { + + inline bool skipString(const UChar*& ptr, const UChar* end, const UChar* name, int length) + { + if (end - ptr < length) + return false; + if (memcmp(name, ptr, sizeof(UChar) * length)) + return false; + ptr += length; + return true; + } + + inline bool skipString(const UChar*& ptr, const UChar* end, const char* str) + { + int length = strlen(str); + if (end - ptr < length) + return false; + for (int i = 0; i < length; ++i) { + if (ptr[i] != str[i]) + return false; + } + ptr += length; + return true; + } + +} // namspace WebCore + +#endif // ParserUtilities_h diff --git a/WebCore/platform/text/PlatformString.h b/WebCore/platform/text/PlatformString.h index f900513..73a44bd 100644 --- a/WebCore/platform/text/PlatformString.h +++ b/WebCore/platform/text/PlatformString.h @@ -27,23 +27,34 @@ #include "StringImpl.h" -#if PLATFORM(CF) +#include <wtf/PassRefPtr.h> + +#if USE(JSC) +#include <kjs/identifier.h> +#else +// kjs/identifier.h includes HashMap.h. We explicitly include it in the case of +// non-JSC builds to keep things consistent. +#include <wtf/HashMap.h> +#endif + +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) typedef const struct __CFString * CFStringRef; #endif #if PLATFORM(QT) +QT_BEGIN_NAMESPACE class QString; +QT_END_NAMESPACE #endif #if PLATFORM(WX) class wxString; #endif - namespace WebCore { class CString; -class DeprecatedString; +class SharedBuffer; struct StringHash; class String { @@ -51,19 +62,28 @@ public: String() { } // gives null string, distinguishable from an empty string String(const UChar*, unsigned length); String(const UChar*); // Specifically for null terminated UTF-16 - String(const KJS::Identifier&); - String(const KJS::UString&); +#if USE(JSC) + String(const JSC::Identifier&); + String(const JSC::UString&); +#endif String(const char*); String(const char*, unsigned length); String(StringImpl* i) : m_impl(i) { } String(PassRefPtr<StringImpl> i) : m_impl(i) { } String(RefPtr<StringImpl> i) : m_impl(i) { } + void swap(String& o) { m_impl.swap(o.m_impl); } + + // Hash table deleted values, which are only constructed and never copied or destroyed. + String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { } + bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); } + static String adopt(StringBuffer& buffer) { return StringImpl::adopt(buffer); } static String adopt(Vector<UChar>& vector) { return StringImpl::adopt(vector); } - operator KJS::Identifier() const; - operator KJS::UString() const; +#if USE(JSC) + operator JSC::UString() const; +#endif unsigned length() const; const UChar* characters() const; @@ -132,17 +152,24 @@ public: static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2); - Vector<String> split(const String& separator, bool allowEmptyEntries = false) const; - Vector<String> split(UChar separator, bool allowEmptyEntries = false) const; + void split(const String& separator, Vector<String>& result) const; + void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const; + void split(UChar separator, Vector<String>& result) const; + void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const; + + int toIntStrict(bool* ok = 0, int base = 10) const; + unsigned toUIntStrict(bool* ok = 0, int base = 10) const; + int64_t toInt64Strict(bool* ok = 0, int base = 10) const; + uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const; int toInt(bool* ok = 0) const; + unsigned toUInt(bool* ok = 0) const; int64_t toInt64(bool* ok = 0) const; uint64_t toUInt64(bool* ok = 0) const; double toDouble(bool* ok = 0) const; float toFloat(bool* ok = 0) const; - Length* toLengthArray(int& len) const; - Length* toCoordsArray(int& len) const; - bool percentage(int &_percentage) const; + + bool percentage(int& percentage) const; // Makes a deep copy. Helpful only if you need to use a String on another thread. // Since the underlying StringImpl objects are immutable, there's no other reason @@ -154,7 +181,7 @@ public: StringImpl* impl() const { return m_impl.get(); } -#if PLATFORM(CF) +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) String(CFStringRef); CFStringRef createCFString() const; #endif @@ -196,10 +223,7 @@ public: // Determines the writing direction using the Unicode Bidi Algorithm rules P2 and P3. WTF::Unicode::Direction defaultWritingDirection() const { return m_impl ? m_impl->defaultWritingDirection() : WTF::Unicode::LeftToRight; } - - String(const DeprecatedString&); - DeprecatedString deprecatedString() const; - + private: RefPtr<StringImpl> m_impl; }; @@ -222,13 +246,30 @@ inline bool equalIgnoringCase(const String& a, const String& b) { return equalIg inline bool equalIgnoringCase(const String& a, const char* b) { return equalIgnoringCase(a.impl(), b); } inline bool equalIgnoringCase(const char* a, const String& b) { return equalIgnoringCase(a, b.impl()); } -bool operator==(const String& a, const DeprecatedString& b); -inline bool operator==(const DeprecatedString& b, const String& a) { return a == b; } -inline bool operator!=(const String& a, const DeprecatedString& b) { return !(a == b); } -inline bool operator!=(const DeprecatedString& b, const String& a ) { return !(a == b); } - inline bool operator!(const String& str) { return str.isNull(); } +inline void swap(String& a, String& b) { a.swap(b); } + +// String Operations + +bool charactersAreAllASCII(const UChar*, size_t); + +int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10); +unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10); +int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10); +uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10); + +int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage +unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage +int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage +uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage + +double charactersToDouble(const UChar*, size_t, bool* ok = 0); +float charactersToFloat(const UChar*, size_t, bool* ok = 0); + +int find(const UChar*, size_t, UChar, int startPosition = 0); +int reverseFind(const UChar*, size_t, UChar, int startPosition = -1); + #ifdef __OBJC__ // This is for situations in WebKit where the long standing behavior has been // "nil if empty", so we try to maintain longstanding behavior for the sake of @@ -236,8 +277,73 @@ inline bool operator!(const String& str) { return str.isNull(); } inline NSString* nsStringNilIfEmpty(const String& str) { return str.isEmpty() ? nil : (NSString*)str; } #endif +inline bool charactersAreAllASCII(const UChar* characters, size_t length) +{ + UChar ored = 0; + for (size_t i = 0; i < length; ++i) + ored |= characters[i]; + return !(ored & 0xFF80); } +inline int find(const UChar* characters, size_t length, UChar character, int startPosition) +{ + if (startPosition >= static_cast<int>(length)) + return -1; + for (size_t i = startPosition; i < length; ++i) { + if (characters[i] == character) + return static_cast<int>(i); + } + return -1; +} + +inline int reverseFind(const UChar* characters, size_t length, UChar character, int startPosition) +{ + if (startPosition >= static_cast<int>(length) || !length) + return -1; + if (startPosition < 0) + startPosition += static_cast<int>(length); + while (true) { + if (characters[startPosition] == character) + return startPosition; + if (!startPosition) + return -1; + startPosition--; + } + ASSERT_NOT_REACHED(); + return -1; +} + +inline void append(Vector<UChar>& vector, const String& string) +{ + vector.append(string.characters(), string.length()); +} + +inline void appendNumber(Vector<UChar>& vector, unsigned char number) +{ + int numberLength = number > 99 ? 3 : (number > 9 ? 2 : 1); + size_t vectorSize = vector.size(); + vector.grow(vectorSize + numberLength); + + switch (numberLength) { + case 3: + vector[vectorSize + 2] = number % 10 + '0'; + number /= 10; + + case 2: + vector[vectorSize + 1] = number % 10 + '0'; + number /= 10; + + case 1: + vector[vectorSize] = number % 10 + '0'; + } +} + + + +PassRefPtr<SharedBuffer> utf8Buffer(const String&); + +} // namespace WebCore + namespace WTF { // StringHash is the default hash for String diff --git a/WebCore/platform/text/RegularExpression.cpp b/WebCore/platform/text/RegularExpression.cpp index 0c26d33..1b933ff 100644 --- a/WebCore/platform/text/RegularExpression.cpp +++ b/WebCore/platform/text/RegularExpression.cpp @@ -1,5 +1,6 @@ /* - * Copyright (C) 2004 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2004, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2008 Collabora Ltd. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,6 +27,7 @@ #include "config.h" #include "RegularExpression.h" +#include "PlatformString.h" #include "Logging.h" #include <wtf/RefCounted.h> #include <pcre/pcre.h> @@ -36,73 +38,47 @@ namespace WebCore { const size_t maxSubstrings = 10; const size_t maxOffsets = 3 * maxSubstrings; -class RegularExpression::Private : public RefCounted<RegularExpression::Private> -{ +class RegularExpression::Private : public RefCounted<Private> { public: - Private(); - Private(DeprecatedString pattern, bool caseSensitive, bool glob); + static PassRefPtr<Private> create() { return adoptRef(new Private); } + static PassRefPtr<Private> create(const String& pattern, bool caseSensitive) { return adoptRef(new Private(pattern, caseSensitive)); } + ~Private(); - void compile(bool caseSensitive, bool glob); + void compile(bool caseSensitive); - DeprecatedString pattern; + String pattern; JSRegExp* regex; - DeprecatedString lastMatchString; + String lastMatchString; int lastMatchOffsets[maxOffsets]; int lastMatchCount; int lastMatchPos; int lastMatchLength; + +private: + Private(); + Private(const String& pattern, bool caseSensitive); }; -RegularExpression::Private::Private() : pattern("") +RegularExpression::Private::Private() + : pattern("") { - compile(true, false); + compile(true); } -RegularExpression::Private::Private(DeprecatedString p, bool caseSensitive, bool glob) : pattern(p), lastMatchPos(-1), lastMatchLength(-1) +RegularExpression::Private::Private(const String& p, bool caseSensitive) + : pattern(p) + , lastMatchPos(-1) + , lastMatchLength(-1) { - compile(caseSensitive, glob); + compile(caseSensitive); } -static DeprecatedString RegExpFromGlob(DeprecatedString glob) +void RegularExpression::Private::compile(bool caseSensitive) { - DeprecatedString result = glob; - - // escape regexp metacharacters which are NOT glob metacharacters - - result.replace(RegularExpression("\\\\"), "\\\\"); - result.replace(RegularExpression("\\."), "\\."); - result.replace(RegularExpression("\\+"), "\\+"); - result.replace(RegularExpression("\\$"), "\\$"); - // FIXME: incorrect for ^ inside bracket group - result.replace(RegularExpression("\\^"), "\\^"); - - // translate glob metacharacters into regexp metacharacters - result.replace(RegularExpression("\\*"), ".*"); - result.replace(RegularExpression("\\?"), "."); - - // Require the glob to match the whole string - result = "^" + result + "$"; - - return result; -} - -void RegularExpression::Private::compile(bool caseSensitive, bool glob) -{ - DeprecatedString p; - - if (glob) { - p = RegExpFromGlob(pattern); - } else { - p = pattern; - } - // Note we don't honor the Qt syntax for various character classes. If we convert - // to a different underlying engine, we may need to change client code that relies - // on the regex syntax (see FrameMac.mm for a couple examples). - const char* errorMessage; - regex = jsRegExpCompile(reinterpret_cast<const UChar*>(p.unicode()), p.length(), + regex = jsRegExpCompile(pattern.characters(), pattern.length(), caseSensitive ? JSRegExpDoNotIgnoreCase : JSRegExpIgnoreCase, JSRegExpSingleLine, 0, &errorMessage); if (!regex) @@ -115,20 +91,24 @@ RegularExpression::Private::~Private() } -RegularExpression::RegularExpression() : d(new RegularExpression::Private()) +RegularExpression::RegularExpression() + : d(Private::create()) { } -RegularExpression::RegularExpression(const DeprecatedString &pattern, bool caseSensitive, bool glob) : d(new RegularExpression::Private(pattern, caseSensitive, glob)) +RegularExpression::RegularExpression(const String& pattern, bool caseSensitive) + : d(Private::create(pattern, caseSensitive)) { } -RegularExpression::RegularExpression(const char *cpattern) : d(new RegularExpression::Private(cpattern, true, false)) +RegularExpression::RegularExpression(const char* pattern) + : d(Private::create(pattern, true)) { } -RegularExpression::RegularExpression(const RegularExpression &re) : d (re.d) +RegularExpression::RegularExpression(const RegularExpression& re) + : d(re.d) { } @@ -136,57 +116,54 @@ RegularExpression::~RegularExpression() { } -RegularExpression &RegularExpression::operator=(const RegularExpression &re) +RegularExpression& RegularExpression::operator=(const RegularExpression& re) { RegularExpression tmp(re); - RefPtr<RegularExpression::Private> tmpD = tmp.d; - - tmp.d = d; - d = tmpD; - + tmp.d.swap(d); return *this; } -DeprecatedString RegularExpression::pattern() const +String RegularExpression::pattern() const { return d->pattern; } -int RegularExpression::match(const DeprecatedString &str, int startFrom, int *matchLength) const +int RegularExpression::match(const String& str, int startFrom, int* matchLength) const { + if (str.isNull()) + return -1; + d->lastMatchString = str; // First 2 offsets are start and end offsets; 3rd entry is used internally by pcre - d->lastMatchCount = jsRegExpExecute(d->regex, reinterpret_cast<const UChar*>(d->lastMatchString.unicode()), d->lastMatchString.length(), startFrom, d->lastMatchOffsets, maxOffsets); + d->lastMatchCount = jsRegExpExecute(d->regex, d->lastMatchString.characters(), + d->lastMatchString.length(), startFrom, d->lastMatchOffsets, maxOffsets); if (d->lastMatchCount < 0) { if (d->lastMatchCount != JSRegExpErrorNoMatch) LOG_ERROR("RegularExpression: pcre_exec() failed with result %d", d->lastMatchCount); d->lastMatchPos = -1; d->lastMatchLength = -1; - d->lastMatchString = DeprecatedString(); + d->lastMatchString = String(); return -1; } // 1 means 1 match; 0 means more than one match. First match is recorded in offsets. - //ASSERT(d->lastMatchCount < 2); d->lastMatchPos = d->lastMatchOffsets[0]; d->lastMatchLength = d->lastMatchOffsets[1] - d->lastMatchOffsets[0]; - if (matchLength != NULL) { + if (matchLength) *matchLength = d->lastMatchLength; - } return d->lastMatchPos; } -int RegularExpression::search(const DeprecatedString &str, int startFrom) const +int RegularExpression::search(const String& str, int startFrom) const { - if (startFrom < 0) { + if (startFrom < 0) startFrom = str.length() - startFrom; - } - return match(str, startFrom, NULL); + return match(str, startFrom, 0); } -int RegularExpression::searchRev(const DeprecatedString &str) const +int RegularExpression::searchRev(const String& str) const { - // FIXME: Total hack for now. Search forward, return the last, greedy match + // FIXME: Total hack for now. Search forward, return the last, greedy match int start = 0; int pos; int lastPos = -1; @@ -195,7 +172,7 @@ int RegularExpression::searchRev(const DeprecatedString &str) const int matchLength; pos = match(str, start, &matchLength); if (pos >= 0) { - if ((pos+matchLength) > (lastPos+lastMatchLength)) { + if (pos + matchLength > lastPos + lastMatchLength) { // replace last match if this one is later and not a subset of the last match lastPos = pos; lastMatchLength = matchLength; @@ -219,4 +196,19 @@ int RegularExpression::matchedLength() const return d->lastMatchLength; } +void replace(String& string, const RegularExpression& target, const String& replacement) +{ + int index = 0; + while (index < static_cast<int>(string.length())) { + int matchLength; + index = target.match(string, index, &matchLength); + if (index < 0) + break; + string.replace(index, matchLength, replacement); + index += replacement.length(); + if (!matchLength) + break; // Avoid infinite loop on 0-length matches, e.g. [a-z]* + } } + +} // namespace WebCore diff --git a/WebCore/platform/text/RegularExpression.h b/WebCore/platform/text/RegularExpression.h index ec1cdef..5d1991e 100644 --- a/WebCore/platform/text/RegularExpression.h +++ b/WebCore/platform/text/RegularExpression.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2003 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2003, 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,34 +26,38 @@ #ifndef RegularExpression_h #define RegularExpression_h -#include "DeprecatedString.h" +#include <wtf/RefPtr.h> namespace WebCore { +class String; + class RegularExpression { public: RegularExpression(); - RegularExpression(const DeprecatedString &, bool caseSensitive = false, bool glob = false); - RegularExpression(const char *); + RegularExpression(const String&, bool caseSensitive = false); + RegularExpression(const char*); ~RegularExpression(); - RegularExpression(const RegularExpression &); - RegularExpression &operator=(const RegularExpression &); + RegularExpression(const RegularExpression&); + RegularExpression& operator=(const RegularExpression&); - DeprecatedString pattern() const; - int match(const DeprecatedString &, int startFrom = 0, int *matchLength = 0) const; + String pattern() const; + int match(const String&, int startFrom = 0, int* matchLength = 0) const; - int search(const DeprecatedString &, int startFrom = 0) const; - int searchRev(const DeprecatedString &) const; + int search(const String&, int startFrom = 0) const; + int searchRev(const String&) const; int pos(int n = 0); int matchedLength() const; - + private: class Private; RefPtr<Private> d; }; -} +void replace(String&, const RegularExpression&, const String&); + +} // namespace WebCore -#endif +#endif // RegularExpression_h diff --git a/WebCore/platform/text/SegmentedString.cpp b/WebCore/platform/text/SegmentedString.cpp index 0b3c7e9..9f5eb26 100644 --- a/WebCore/platform/text/SegmentedString.cpp +++ b/WebCore/platform/text/SegmentedString.cpp @@ -1,5 +1,5 @@ /* - Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved. + Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public @@ -59,10 +59,10 @@ unsigned SegmentedString::length() const ++length; } if (m_composite) { - DeprecatedValueListConstIterator<SegmentedSubstring> i = m_substrings.begin(); - DeprecatedValueListConstIterator<SegmentedSubstring> e = m_substrings.end(); - for (; i != e; ++i) - length += (*i).m_length; + Deque<SegmentedSubstring>::const_iterator it = m_substrings.begin(); + Deque<SegmentedSubstring>::const_iterator e = m_substrings.end(); + for (; it != e; ++it) + length += it->m_length; } return length; } @@ -70,10 +70,10 @@ unsigned SegmentedString::length() const void SegmentedString::setExcludeLineNumbers() { if (m_composite) { - DeprecatedValueListIterator<SegmentedSubstring> i = m_substrings.begin(); - DeprecatedValueListIterator<SegmentedSubstring> e = m_substrings.end(); - for (; i != e; ++i) - (*i).setExcludeLineNumbers(); + Deque<SegmentedSubstring>::iterator it = m_substrings.begin(); + Deque<SegmentedSubstring>::iterator e = m_substrings.end(); + for (; it != e; ++it) + it->setExcludeLineNumbers(); } else m_currentString.setExcludeLineNumbers(); } @@ -120,10 +120,10 @@ void SegmentedString::append(const SegmentedString &s) ASSERT(!s.escaped()); append(s.m_currentString); if (s.m_composite) { - DeprecatedValueListConstIterator<SegmentedSubstring> i = s.m_substrings.begin(); - DeprecatedValueListConstIterator<SegmentedSubstring> e = s.m_substrings.end(); - for (; i != e; ++i) - append(*i); + Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin(); + Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end(); + for (; it != e; ++it) + append(*it); } m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current; } @@ -133,10 +133,10 @@ void SegmentedString::prepend(const SegmentedString &s) ASSERT(!escaped()); ASSERT(!s.escaped()); if (s.m_composite) { - DeprecatedValueListConstIterator<SegmentedSubstring> i = s.m_substrings.fromLast(); - DeprecatedValueListConstIterator<SegmentedSubstring> e = s.m_substrings.end(); - for (; i != e; --i) - prepend(*i); + Deque<SegmentedSubstring>::const_reverse_iterator it = s.m_substrings.rbegin(); + Deque<SegmentedSubstring>::const_reverse_iterator e = s.m_substrings.rend(); + for (; it != e; ++it) + prepend(*it); } prepend(s.m_currentString); m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current; @@ -146,7 +146,7 @@ void SegmentedString::advanceSubstring() { if (m_composite) { m_currentString = m_substrings.first(); - m_substrings.remove(m_substrings.begin()); + m_substrings.removeFirst(); if (m_substrings.isEmpty()) m_composite = false; } else { @@ -164,10 +164,10 @@ String SegmentedString::toString() const } m_currentString.appendTo(result); if (m_composite) { - DeprecatedValueListConstIterator<SegmentedSubstring> i = m_substrings.begin(); - DeprecatedValueListConstIterator<SegmentedSubstring> e = m_substrings.end(); - for (; i != e; ++i) - (*i).appendTo(result); + Deque<SegmentedSubstring>::const_iterator it = m_substrings.begin(); + Deque<SegmentedSubstring>::const_iterator e = m_substrings.end(); + for (; it != e; ++it) + it->appendTo(result); } return result; } diff --git a/WebCore/platform/text/SegmentedString.h b/WebCore/platform/text/SegmentedString.h index 52178d3..79ed1f0 100644 --- a/WebCore/platform/text/SegmentedString.h +++ b/WebCore/platform/text/SegmentedString.h @@ -20,20 +20,22 @@ #ifndef SegmentedString_h #define SegmentedString_h -#include "DeprecatedValueList.h" #include "PlatformString.h" +#include <wtf/Deque.h> namespace WebCore { class SegmentedString; class SegmentedSubstring { -private: - friend class SegmentedString; - +public: SegmentedSubstring() : m_length(0), m_current(0), m_doNotExcludeLineNumbers(true) {} - SegmentedSubstring(const String& str) : m_string(str), m_length(str.length()), m_doNotExcludeLineNumbers(true) { - m_current = m_length == 0 ? 0 : m_string.characters(); + SegmentedSubstring(const String& str) + : m_length(str.length()) + , m_current(str.isEmpty() ? 0 : str.characters()) + , m_string(str) + , m_doNotExcludeLineNumbers(true) + { } SegmentedSubstring(const UChar* str, int length) : m_length(length), m_current(length == 0 ? 0 : str), m_doNotExcludeLineNumbers(true) {} @@ -45,7 +47,8 @@ private: void setExcludeLineNumbers() { m_doNotExcludeLineNumbers = false; } - void appendTo(String& str) const { + void appendTo(String& str) const + { if (m_string.characters() == m_current) { if (str.isEmpty()) str = m_string; @@ -56,9 +59,12 @@ private: } } - String m_string; +public: int m_length; const UChar* m_current; + +private: + String m_string; bool m_doNotExcludeLineNumbers; }; @@ -77,8 +83,8 @@ public: void clear(); - void append(const SegmentedString &); - void prepend(const SegmentedString &); + void append(const SegmentedString&); + void prepend(const SegmentedString&); bool excludeLineNumbers() const { return m_currentString.excludeLineNumbers(); } void setExcludeLineNumbers(); @@ -149,8 +155,8 @@ public: const UChar* operator->() const { return current(); } private: - void append(const SegmentedSubstring &); - void prepend(const SegmentedSubstring &); + void append(const SegmentedSubstring&); + void prepend(const SegmentedSubstring&); void advanceSlowCase(); void advanceSlowCase(int& lineNumber); @@ -161,7 +167,7 @@ private: UChar m_pushedChar2; SegmentedSubstring m_currentString; const UChar* m_currentChar; - DeprecatedValueList<SegmentedSubstring> m_substrings; + Deque<SegmentedSubstring> m_substrings; bool m_composite; }; diff --git a/WebCore/platform/text/String.cpp b/WebCore/platform/text/String.cpp index 967e7c8..44500e1 100644 --- a/WebCore/platform/text/String.cpp +++ b/WebCore/platform/text/String.cpp @@ -22,16 +22,25 @@ #include "PlatformString.h" #include "CString.h" -#include "DeprecatedString.h" +#include "FloatConversion.h" #include "StringBuffer.h" #include "TextEncoding.h" -#include <kjs/identifier.h> +#include <kjs/dtoa.h> +#include <limits> +#include <stdarg.h> +#include <wtf/ASCIICType.h> #include <wtf/StringExtras.h> #include <wtf/Vector.h> -#include <stdarg.h> +#include <wtf/unicode/Unicode.h> +#include <wtf/unicode/UTF8.h> + +#if USE(JSC) +using JSC::Identifier; +using JSC::UString; +#endif -using KJS::Identifier; -using KJS::UString; +using namespace WTF; +using namespace WTF::Unicode; namespace WebCore { @@ -54,13 +63,6 @@ String::String(const UChar* str) m_impl = StringImpl::create(str, len); } -String::String(const DeprecatedString& str) -{ - if (str.isNull()) - return; - m_impl = StringImpl::create(reinterpret_cast<const UChar*>(str.unicode()), str.length()); -} - String::String(const char* str) { if (!str) @@ -289,7 +291,7 @@ bool String::percentage(int& result) const if ((*m_impl)[m_impl->length() - 1] != '%') return false; - result = DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_impl->characters()), m_impl->length() - 1).string().toInt(); + result = charactersToIntStrict(m_impl->characters(), m_impl->length() - 1); return true; } @@ -310,17 +312,21 @@ const UChar* String::charactersWithNullTermination() return m_impl->characters(); } -DeprecatedString String::deprecatedString() const -{ - if (!m_impl) - return DeprecatedString::null; - if (!m_impl->characters()) - return DeprecatedString("", 0); - return DeprecatedString(reinterpret_cast<const DeprecatedChar*>(m_impl->characters()), m_impl->length()); -} - String String::format(const char *format, ...) { +#if PLATFORM(QT) + // Use QString::vsprintf to avoid the locale dependent formatting of vsnprintf. + // https://bugs.webkit.org/show_bug.cgi?id=18994 + va_list args; + va_start(args, format); + + QString buffer; + buffer.vsprintf(format, args); + + va_end(args); + + return buffer; +#else va_list args; va_start(args, format); @@ -355,6 +361,7 @@ String String::format(const char *format, ...) va_end(args); return StringImpl::create(buffer.data(), len); +#endif } String String::number(int n) @@ -400,6 +407,46 @@ String String::number(double n) return String::format("%.6lg", n); } +int String::toIntStrict(bool* ok, int base) const +{ + if (!m_impl) { + if (ok) + *ok = false; + return 0; + } + return m_impl->toIntStrict(ok, base); +} + +unsigned String::toUIntStrict(bool* ok, int base) const +{ + if (!m_impl) { + if (ok) + *ok = false; + return 0; + } + return m_impl->toUIntStrict(ok, base); +} + +int64_t String::toInt64Strict(bool* ok, int base) const +{ + if (!m_impl) { + if (ok) + *ok = false; + return 0; + } + return m_impl->toInt64Strict(ok, base); +} + +uint64_t String::toUInt64Strict(bool* ok, int base) const +{ + if (!m_impl) { + if (ok) + *ok = false; + return 0; + } + return m_impl->toUInt64Strict(ok, base); +} + int String::toInt(bool* ok) const { if (!m_impl) { @@ -410,6 +457,16 @@ int String::toInt(bool* ok) const return m_impl->toInt(ok); } +unsigned String::toUInt(bool* ok) const +{ + if (!m_impl) { + if (ok) + *ok = false; + return 0; + } + return m_impl->toUInt(ok); +} + int64_t String::toInt64(bool* ok) const { if (!m_impl) { @@ -435,7 +492,7 @@ double String::toDouble(bool* ok) const if (!m_impl) { if (ok) *ok = false; - return 0; + return 0.0; } return m_impl->toDouble(ok); } @@ -462,38 +519,44 @@ bool String::isEmpty() const return !m_impl || !m_impl->length(); } -Length* String::toCoordsArray(int& len) const +void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const { - return m_impl ? m_impl->toCoordsArray(len) : 0; + result.clear(); + + int startPos = 0; + int endPos; + while ((endPos = find(separator, startPos)) != -1) { + if (allowEmptyEntries || startPos != endPos) + result.append(substring(startPos, endPos - startPos)); + startPos = endPos + separator.length(); + } + if (allowEmptyEntries || startPos != static_cast<int>(length())) + result.append(substring(startPos)); } -Length* String::toLengthArray(int& len) const +void String::split(const String& separator, Vector<String>& result) const { - return m_impl ? m_impl->toLengthArray(len) : 0; + return split(separator, false, result); } -Vector<String> String::split(const String& separator, bool allowEmptyEntries) const +void String::split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const { - Vector<String> result; - + result.clear(); + int startPos = 0; int endPos; while ((endPos = find(separator, startPos)) != -1) { if (allowEmptyEntries || startPos != endPos) result.append(substring(startPos, endPos - startPos)); - startPos = endPos + separator.length(); + startPos = endPos + 1; } - if (allowEmptyEntries || startPos != (int)length()) + if (allowEmptyEntries || startPos != static_cast<int>(length())) result.append(substring(startPos)); - - return result; } -Vector<String> String::split(UChar separator, bool allowEmptyEntries) const +void String::split(UChar separator, Vector<String>& result) const { - Vector<String> result; - - return split(String(&separator, 1), allowEmptyEntries); + return split(String(&separator, 1), false, result); } #ifndef NDEBUG @@ -514,61 +577,247 @@ Vector<char> String::ascii() const CString String::latin1() const { - return Latin1Encoding().encode(characters(), length()); + return Latin1Encoding().encode(characters(), length(), QuestionMarksForUnencodables); } CString String::utf8() const { - return UTF8Encoding().encode(characters(), length()); + return UTF8Encoding().encode(characters(), length(), QuestionMarksForUnencodables); } String String::fromUTF8(const char* string, size_t size) { + if (!string) + return String(); return UTF8Encoding().decode(string, size); } String String::fromUTF8(const char* string) { + if (!string) + return String(); return UTF8Encoding().decode(string, strlen(string)); } - -bool operator==(const String& a, const DeprecatedString& b) -{ - unsigned l = a.length(); - if (l != b.length()) - return false; - if (!memcmp(a.characters(), b.unicode(), l * sizeof(UChar))) - return true; - return false; -} - +#if USE(JSC) String::String(const Identifier& str) { if (str.isNull()) return; - m_impl = StringImpl::create(reinterpret_cast<const UChar*>(str.data()), str.size()); + m_impl = StringImpl::create(str.data(), str.size()); } String::String(const UString& str) { if (str.isNull()) return; - m_impl = StringImpl::create(reinterpret_cast<const UChar*>(str.data()), str.size()); + m_impl = StringImpl::create(str.data(), str.size()); } -String::operator Identifier() const +String::operator UString() const { if (!m_impl) - return Identifier(); - return Identifier(reinterpret_cast<const KJS::UChar*>(m_impl->characters()), m_impl->length()); + return UString(); + return UString(m_impl->characters(), m_impl->length()); } +#endif -String::operator UString() const +// String Operations + +static bool isCharacterAllowedInBase(UChar c, int base) { - if (!m_impl) - return UString(); - return UString(reinterpret_cast<const KJS::UChar*>(m_impl->characters()), m_impl->length()); + if (c > 0x7F) + return false; + if (isASCIIDigit(c)) + return c - '0' < base; + if (isASCIIAlpha(c)) { + if (base > 36) + base = 36; + return (c >= 'a' && c < 'a' + base - 10) + || (c >= 'A' && c < 'A' + base - 10); + } + return false; +} + +template <typename IntegralType> +static inline IntegralType toIntegralType(const UChar* data, size_t length, bool* ok, int base) +{ + static const IntegralType integralMax = std::numeric_limits<IntegralType>::max(); + static const bool isSigned = std::numeric_limits<IntegralType>::is_signed; + const IntegralType maxMultiplier = integralMax / base; + + IntegralType value = 0; + bool isOk = false; + bool isNegative = false; + + if (!data) + goto bye; + + // skip leading whitespace + while (length && isSpaceOrNewline(*data)) { + length--; + data++; + } + + if (isSigned && length && *data == '-') { + length--; + data++; + isNegative = true; + } else if (length && *data == '+') { + length--; + data++; + } + + if (!length || !isCharacterAllowedInBase(*data, base)) + goto bye; + + while (length && isCharacterAllowedInBase(*data, base)) { + length--; + IntegralType digitValue; + UChar c = *data; + if (isASCIIDigit(c)) + digitValue = c - '0'; + else if (c >= 'a') + digitValue = c - 'a' + 10; + else + digitValue = c - 'A' + 10; + + if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative)) + goto bye; + + value = base * value + digitValue; + data++; + } + +#if COMPILER(MSVC) +#pragma warning(push, 0) +#pragma warning(disable:4146) +#endif + + if (isNegative) + value = -value; + +#if COMPILER(MSVC) +#pragma warning(pop) +#endif + + // skip trailing space + while (length && isSpaceOrNewline(*data)) { + length--; + data++; + } + + if (!length) + isOk = true; +bye: + if (ok) + *ok = isOk; + return isOk ? value : 0; +} + +static unsigned lengthOfCharactersAsInteger(const UChar* data, size_t length) +{ + size_t i = 0; + + // Allow leading spaces. + for (; i != length; ++i) { + if (!isSpaceOrNewline(data[i])) + break; + } + + // Allow sign. + if (i != length && (data[i] == '+' || data[i] == '-')) + ++i; + + // Allow digits. + for (; i != length; ++i) { + if (!isASCIIDigit(data[i])) + break; + } + + return i; +} + +int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base) +{ + return toIntegralType<int>(data, length, ok, base); +} + +unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base) +{ + return toIntegralType<unsigned>(data, length, ok, base); +} + +int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base) +{ + return toIntegralType<int64_t>(data, length, ok, base); +} + +uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base) +{ + return toIntegralType<uint64_t>(data, length, ok, base); +} + +int charactersToInt(const UChar* data, size_t length, bool* ok) +{ + return toIntegralType<int>(data, lengthOfCharactersAsInteger(data, length), ok, 10); +} + +unsigned charactersToUInt(const UChar* data, size_t length, bool* ok) +{ + return toIntegralType<unsigned>(data, lengthOfCharactersAsInteger(data, length), ok, 10); +} + +int64_t charactersToInt64(const UChar* data, size_t length, bool* ok) +{ + return toIntegralType<int64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10); +} + +uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok) +{ + return toIntegralType<uint64_t>(data, lengthOfCharactersAsInteger(data, length), ok, 10); +} + +double charactersToDouble(const UChar* data, size_t length, bool* ok) +{ + if (!length) { + if (ok) + *ok = false; + return 0.0; + } + + Vector<char, 256> bytes(length + 1); + for (unsigned i = 0; i < length; ++i) + bytes[i] = data[i] < 0x7F ? data[i] : '?'; + bytes[length] = '\0'; + char* end; + double val = JSC::strtod(bytes.data(), &end); + if (ok) + *ok = (end == 0 || *end == '\0'); + return val; +} + +float charactersToFloat(const UChar* data, size_t length, bool* ok) +{ + // FIXME: This will return ok even when the string fits into a double but not a float. + return narrowPrecisionToFloat(charactersToDouble(data, length, ok)); +} + +PassRefPtr<SharedBuffer> utf8Buffer(const String& string) +{ + // Allocate a buffer big enough to hold all the characters. + const int length = string.length(); + Vector<char> buffer(length * 3); + + // Convert to runs of 8-bit characters. + char* p = buffer.data(); + const UChar* d = string.characters(); + ConversionResult result = convertUTF16ToUTF8(&d, d + length, &p, p + buffer.size(), true); + if (result != conversionOK) + return 0; + + buffer.shrink(p - buffer.data()); + return SharedBuffer::adoptVector(buffer); } } // namespace WebCore diff --git a/WebCore/platform/text/StringBuilder.cpp b/WebCore/platform/text/StringBuilder.cpp new file mode 100644 index 0000000..0e9555c --- /dev/null +++ b/WebCore/platform/text/StringBuilder.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "StringBuilder.h" + +#include "StringBuffer.h" + +namespace WebCore { + +void StringBuilder::append(const String& string) +{ + if (string.isNull()) + return; + + if (m_totalLength == UINT_MAX) + m_totalLength = string.length(); + else + m_totalLength += string.length(); + + if (!string.isEmpty()) + m_strings.append(string); +} + +void StringBuilder::append(UChar c) +{ + if (m_totalLength == UINT_MAX) + m_totalLength = 1; + else + m_totalLength += 1; + + m_strings.append(String(&c, 1)); +} + +void StringBuilder::append(char c) +{ + if (m_totalLength == UINT_MAX) + m_totalLength = 1; + else + m_totalLength += 1; + + m_strings.append(String(&c, 1)); +} + +String StringBuilder::toString() const +{ + if (isNull()) + return String(); + + unsigned count = m_strings.size(); + + if (!count) + return String(StringImpl::empty()); + if (count == 1) + return m_strings[0]; + + StringBuffer buffer(m_totalLength); + + UChar* p = buffer.characters(); + for (unsigned i = 0; i < count; ++i) { + StringImpl* string = m_strings[i].impl(); + unsigned length = string->length(); + memcpy(p, string->characters(), length * 2); + p += length; + } + + ASSERT(p == m_totalLength + buffer.characters()); + + return String::adopt(buffer); +} + +} diff --git a/WebCore/platform/text/StringBuilder.h b/WebCore/platform/text/StringBuilder.h new file mode 100644 index 0000000..8d76b9c --- /dev/null +++ b/WebCore/platform/text/StringBuilder.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef StringBuilder_h +#define StringBuilder_h + +#include "PlatformString.h" + +namespace WebCore { + + class StringBuilder { + public: + StringBuilder() : m_totalLength(UINT_MAX) {} + + void setNonNull() { if (m_totalLength == UINT_MAX) m_totalLength = 0; } + + void append(const String&); + void append(UChar); + void append(char); + + String toString() const; + + private: + bool isNull() const { return m_totalLength == UINT_MAX; } + + unsigned m_totalLength; + Vector<String, 16> m_strings; + }; + +} + +#endif diff --git a/WebCore/platform/text/StringHash.h b/WebCore/platform/text/StringHash.h index 375b2e4..c6e08a6 100644 --- a/WebCore/platform/text/StringHash.h +++ b/WebCore/platform/text/StringHash.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006, 2007 Apple Inc. All rights reserved + * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -28,6 +28,10 @@ namespace WebCore { + // FIXME: We should really figure out a way to put the computeHash function that's + // currently a member function of StringImpl into this file so we can be a little + // closer to having all the nearly-identical hash functions in one place. + struct StringHash { static unsigned hash(StringImpl* key) { return key->hash(); } static bool equal(StringImpl* a, StringImpl* b) @@ -78,17 +82,17 @@ namespace WebCore { public: // Paul Hsieh's SuperFastHash // http://www.azillionmonkeys.com/qed/hash.html - static unsigned hash(StringImpl* str) + static unsigned hash(const UChar* data, unsigned length) { - unsigned l = str->length(); - const UChar* s = str->characters(); + unsigned l = length; + const UChar* s = data; uint32_t hash = PHI; uint32_t tmp; int rem = l & 1; l >>= 1; - // Main loop + // Main loop. for (; l > 0; l--) { hash += WTF::Unicode::foldCase(s[0]); tmp = (WTF::Unicode::foldCase(s[1]) << 11) ^ hash; @@ -97,28 +101,32 @@ namespace WebCore { hash += hash >> 11; } - // Handle end case + // Handle end case. if (rem) { hash += WTF::Unicode::foldCase(s[0]); hash ^= hash << 11; hash += hash >> 17; } - // Force "avalanching" of final 127 bits + // Force "avalanching" of final 127 bits. hash ^= hash << 3; hash += hash >> 5; hash ^= hash << 2; hash += hash >> 15; hash ^= hash << 10; - // this avoids ever returning a hash code of 0, since that is used to + // This avoids ever returning a hash code of 0, since that is used to // signal "hash not computed yet", using a value that is likely to be - // effectively the same as 0 when the low bits are masked - if (hash == 0) - hash = 0x80000000; + // effectively the same as 0 when the low bits are masked. + hash |= !hash << 31; return hash; } + + static unsigned hash(StringImpl* str) + { + return hash(str->characters(), str->length()); + } static unsigned hash(const char* str, unsigned length) { @@ -160,8 +168,7 @@ namespace WebCore { // this avoids ever returning a hash code of 0, since that is used to // signal "hash not computed yet", using a value that is likely to be // effectively the same as 0 when the low bits are masked - if (hash == 0) - hash = 0x80000000; + hash |= !hash << 31; return hash; } @@ -200,48 +207,34 @@ namespace WebCore { static const bool safeToCompareToEmptyOrDeleted = false; }; + // This hash can be used in cases where the key is a hash of a string, but we don't + // want to store the string. It's not really specific to string hashing, but all our + // current uses of it are for strings. + struct AlreadyHashed : IntHash<unsigned> { + static unsigned hash(unsigned key) { return key; } + + // To use a hash value as a key for a hash table, we need to eliminate the + // "deleted" value, which is negative one. That could be done by changing + // the string hash function to never generate negative one, but this works + // and is still relatively efficient. + static unsigned avoidDeletedValue(unsigned hash) + { + ASSERT(hash); + unsigned newHash = hash | (!(hash + 1) << 31); + ASSERT(newHash); + ASSERT(newHash != 0xFFFFFFFF); + return newHash; + } + }; + } namespace WTF { - // store WebCore::String as StringImpl* - template<> struct HashTraits<WebCore::String> : GenericHashTraits<WebCore::String> { - typedef HashTraits<WebCore::StringImpl*>::StorageTraits StorageTraits; - typedef StorageTraits::TraitType StorageType; static const bool emptyValueIsZero = true; - static const bool needsRef = true; - - typedef union { - WebCore::StringImpl* m_p; - StorageType m_s; - } UnionType; - - static void ref(const StorageType& s) { ref(reinterpret_cast<const UnionType*>(&s)->m_p); } - static void deref(const StorageType& s) { deref(reinterpret_cast<const UnionType*>(&s)->m_p); } - - static void ref(const WebCore::StringImpl* str) { if (str) const_cast<WebCore::StringImpl*>(str)->ref(); } - static void deref(const WebCore::StringImpl* str) { if (str) const_cast<WebCore::StringImpl*>(str)->deref(); } - }; - - // share code between StringImpl*, RefPtr<StringImpl>, and String - - template<> struct HashKeyStorageTraits<WebCore::StringHash, HashTraits<RefPtr<WebCore::StringImpl> > > { - typedef WebCore::StringHash Hash; - typedef HashTraits<WebCore::StringImpl*> Traits; - }; - template<> struct HashKeyStorageTraits<WebCore::StringHash, HashTraits<WebCore::String> > { - typedef WebCore::StringHash Hash; - typedef HashTraits<WebCore::StringImpl*> Traits; - }; - - template<> struct HashKeyStorageTraits<WebCore::CaseFoldingHash, HashTraits<RefPtr<WebCore::StringImpl> > > { - typedef WebCore::CaseFoldingHash Hash; - typedef HashTraits<WebCore::StringImpl*> Traits; - }; - template<> struct HashKeyStorageTraits<WebCore::CaseFoldingHash, HashTraits<WebCore::String> > { - typedef WebCore::CaseFoldingHash Hash; - typedef HashTraits<WebCore::StringImpl*> Traits; + static void constructDeletedValue(WebCore::String& slot) { new (&slot) WebCore::String(HashTableDeletedValue); } + static bool isDeletedValue(const WebCore::String& slot) { return slot.isHashTableDeletedValue(); } }; } diff --git a/WebCore/platform/text/StringImpl.cpp b/WebCore/platform/text/StringImpl.cpp index 0643de6..911c0dc 100644 --- a/WebCore/platform/text/StringImpl.cpp +++ b/WebCore/platform/text/StringImpl.cpp @@ -28,24 +28,18 @@ #include "AtomicString.h" #include "CString.h" #include "CharacterNames.h" -#include "DeprecatedString.h" #include "FloatConversion.h" -#include "Length.h" #include "StringBuffer.h" #include "StringHash.h" #include "TextBreakIterator.h" #include "TextEncoding.h" #include <kjs/dtoa.h> -#include <kjs/identifier.h> #include <wtf/Assertions.h> #include <wtf/unicode/Unicode.h> using namespace WTF; using namespace Unicode; -using KJS::Identifier; -using KJS::UString; - namespace WebCore { static inline UChar* newUCharVector(unsigned n) @@ -60,21 +54,23 @@ static inline void deleteUCharVector(const UChar* p) // This constructor is used only to create the empty string. StringImpl::StringImpl() - : RefCounted<StringImpl>(1) - , m_length(0) + : m_length(0) , m_data(0) , m_hash(0) , m_inTable(false) , m_hasTerminatingNullCharacter(false) { + // Ensure that the hash is computed so that AtomicStringHash can call existingHash() + // with impunity. The empty string is special because it is never entered into + // AtomicString's HashKey, but still needs to compare correctly. + hash(); } // This is one of the most common constructors, but it's also used for the copy() // operation. Because of that, it's the one constructor that doesn't assert the // length is non-zero, since we support copying the empty string. inline StringImpl::StringImpl(const UChar* characters, unsigned length) - : RefCounted<StringImpl>(1) - , m_length(length) + : m_length(length) , m_hash(0) , m_inTable(false) , m_hasTerminatingNullCharacter(false) @@ -85,8 +81,7 @@ inline StringImpl::StringImpl(const UChar* characters, unsigned length) } inline StringImpl::StringImpl(const StringImpl& str, WithTerminatingNullCharacter) - : RefCounted<StringImpl>(1) - , m_length(str.m_length) + : m_length(str.m_length) , m_hash(str.m_hash) , m_inTable(false) , m_hasTerminatingNullCharacter(true) @@ -98,8 +93,7 @@ inline StringImpl::StringImpl(const StringImpl& str, WithTerminatingNullCharacte } inline StringImpl::StringImpl(const char* characters, unsigned length) - : RefCounted<StringImpl>(1) - , m_length(length) + : m_length(length) , m_hash(0) , m_inTable(false) , m_hasTerminatingNullCharacter(false) @@ -116,8 +110,7 @@ inline StringImpl::StringImpl(const char* characters, unsigned length) } inline StringImpl::StringImpl(UChar* characters, unsigned length, AdoptBuffer) - : RefCounted<StringImpl>(1) - , m_length(length) + : m_length(length) , m_data(characters) , m_hash(0) , m_inTable(false) @@ -127,15 +120,9 @@ inline StringImpl::StringImpl(UChar* characters, unsigned length, AdoptBuffer) ASSERT(length); } -// FIXME: These AtomicString constructors return objects with a refCount of 0, -// even though the others return objects with a refCount of 1. That preserves -// the historical behavior for the hash map translator call sites inside the -// AtomicString code, but is it correct? - // This constructor is only for use by AtomicString. StringImpl::StringImpl(const UChar* characters, unsigned length, unsigned hash) - : RefCounted<StringImpl>(0) - , m_length(length) + : m_length(length) , m_hash(hash) , m_inTable(true) , m_hasTerminatingNullCharacter(false) @@ -151,8 +138,7 @@ StringImpl::StringImpl(const UChar* characters, unsigned length, unsigned hash) // This constructor is only for use by AtomicString. StringImpl::StringImpl(const char* characters, unsigned length, unsigned hash) - : RefCounted<StringImpl>(0) - , m_length(length) + : m_length(length) , m_hash(hash) , m_inTable(true) , m_hasTerminatingNullCharacter(false) @@ -178,8 +164,8 @@ StringImpl::~StringImpl() StringImpl* StringImpl::empty() { - static StringImpl e; - return &e; + static StringImpl* e = new StringImpl; + return e; } bool StringImpl::containsOnlyWhitespace() @@ -211,128 +197,6 @@ UChar32 StringImpl::characterStartingAt(unsigned i) return 0; } -static Length parseLength(const UChar* data, unsigned length) -{ - if (length == 0) - return Length(1, Relative); - - unsigned i = 0; - while (i < length && isSpaceOrNewline(data[i])) - ++i; - if (i < length && (data[i] == '+' || data[i] == '-')) - ++i; - while (i < length && Unicode::isDigit(data[i])) - ++i; - - bool ok; - int r = DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(data), i).string().toInt(&ok); - - /* Skip over any remaining digits, we are not that accurate (5.5% => 5%) */ - while (i < length && (Unicode::isDigit(data[i]) || data[i] == '.')) - ++i; - - /* IE Quirk: Skip any whitespace (20 % => 20%) */ - while (i < length && isSpaceOrNewline(data[i])) - ++i; - - if (ok) { - if (i < length) { - UChar next = data[i]; - if (next == '%') - return Length(static_cast<double>(r), Percent); - if (next == '*') - return Length(r, Relative); - } - return Length(r, Fixed); - } else { - if (i < length) { - UChar next = data[i]; - if (next == '*') - return Length(1, Relative); - if (next == '%') - return Length(1, Relative); - } - } - return Length(0, Relative); -} - -Length StringImpl::toLength() -{ - return parseLength(m_data, m_length); -} - -static int countCharacter(StringImpl* string, UChar character) -{ - int count = 0; - int length = string->length(); - for (int i = 0; i < length; ++i) - count += (*string)[i] == character; - return count; -} - -Length* StringImpl::toCoordsArray(int& len) -{ - StringBuffer spacified(m_length); - for (unsigned i = 0; i < m_length; i++) { - UChar cc = m_data[i]; - if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.')) - spacified[i] = ' '; - else - spacified[i] = cc; - } - RefPtr<StringImpl> str = adopt(spacified); - - str = str->simplifyWhiteSpace(); - - len = countCharacter(str.get(), ' ') + 1; - Length* r = new Length[len]; - - int i = 0; - int pos = 0; - int pos2; - - while ((pos2 = str->find(' ', pos)) != -1) { - r[i++] = parseLength(str->characters() + pos, pos2 - pos); - pos = pos2+1; - } - r[i] = parseLength(str->characters() + pos, str->length() - pos); - - ASSERT(i == len - 1); - - return r; -} - -Length* StringImpl::toLengthArray(int& len) -{ - RefPtr<StringImpl> str = simplifyWhiteSpace(); - if (!str->length()) { - len = 1; - return 0; - } - - len = countCharacter(str.get(), ',') + 1; - Length* r = new Length[len]; - - int i = 0; - int pos = 0; - int pos2; - - while ((pos2 = str->find(',', pos)) != -1) { - r[i++] = parseLength(str->characters() + pos, pos2 - pos); - pos = pos2+1; - } - - ASSERT(i == len - 1); - - /* IE Quirk: If the last comma is the last char skip it and reduce len by one */ - if (str->length()-pos > 0) - r[i] = parseLength(str->characters() + pos, str->length() - pos); - else - len--; - - return r; -} - bool StringImpl::isLower() { // Do a faster loop for the case where all the characters are ASCII. @@ -378,7 +242,7 @@ PassRefPtr<StringImpl> StringImpl::lower() if (!error && realLength == length) return adopt(data); data.resize(realLength); - Unicode::toLower(data.characters(), length, m_data, m_length, &error); + Unicode::toLower(data.characters(), realLength, m_data, m_length, &error); if (error) return this; return adopt(data); @@ -386,10 +250,26 @@ PassRefPtr<StringImpl> StringImpl::lower() PassRefPtr<StringImpl> StringImpl::upper() { + StringBuffer data(m_length); + int32_t length = m_length; + + // Do a faster loop for the case where all the characters are ASCII. + UChar ored = 0; + for (int i = 0; i < length; i++) { + UChar c = m_data[i]; + ored |= c; + data[i] = toASCIIUpper(c); + } + if (!(ored & ~0x7F)) + return adopt(data); + + // Do a slower implementation for cases that include non-ASCII characters. bool error; - int32_t length = Unicode::toUpper(0, 0, m_data, m_length, &error); - StringBuffer data(length); - Unicode::toUpper(data.characters(), length, m_data, m_length, &error); + int32_t realLength = Unicode::toUpper(data.characters(), length, m_data, m_length, &error); + if (!error && realLength == length) + return adopt(data); + data.resize(realLength); + Unicode::toUpper(data.characters(), realLength, m_data, m_length, &error); if (error) return this; return adopt(data); @@ -425,7 +305,7 @@ PassRefPtr<StringImpl> StringImpl::foldCase() if (!error && realLength == length) return adopt(data); data.resize(realLength); - Unicode::foldCase(data.characters(), length, m_data, m_length, &error); + Unicode::foldCase(data.characters(), realLength, m_data, m_length, &error); if (error) return this; return adopt(data); @@ -513,84 +393,54 @@ PassRefPtr<StringImpl> StringImpl::capitalize(UChar previous) return adopt(data); } -int StringImpl::toInt(bool* ok) +int StringImpl::toIntStrict(bool* ok, int base) { - unsigned i = 0; + return charactersToIntStrict(m_data, m_length, ok, base); +} - // Allow leading spaces. - for (; i != m_length; ++i) - if (!isSpaceOrNewline(m_data[i])) - break; - - // Allow sign. - if (i != m_length && (m_data[i] == '+' || m_data[i] == '-')) - ++i; - - // Allow digits. - for (; i != m_length; ++i) - if (!Unicode::isDigit(m_data[i])) - break; - - return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toInt(ok); +unsigned StringImpl::toUIntStrict(bool* ok, int base) +{ + return charactersToUIntStrict(m_data, m_length, ok, base); } -int64_t StringImpl::toInt64(bool* ok) +int64_t StringImpl::toInt64Strict(bool* ok, int base) { - unsigned i = 0; + return charactersToInt64Strict(m_data, m_length, ok, base); +} - // Allow leading spaces. - for (; i != m_length; ++i) - if (!isSpaceOrNewline(m_data[i])) - break; - - // Allow sign. - if (i != m_length && (m_data[i] == '+' || m_data[i] == '-')) - ++i; - - // Allow digits. - for (; i != m_length; ++i) - if (!Unicode::isDigit(m_data[i])) - break; - - return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toInt64(ok); +uint64_t StringImpl::toUInt64Strict(bool* ok, int base) +{ + return charactersToUInt64Strict(m_data, m_length, ok, base); } -uint64_t StringImpl::toUInt64(bool* ok) +int StringImpl::toInt(bool* ok) { - unsigned i = 0; + return charactersToInt(m_data, m_length, ok); +} - // Allow leading spaces. - for (; i != m_length; ++i) - if (!isSpaceOrNewline(m_data[i])) - break; +unsigned StringImpl::toUInt(bool* ok) +{ + return charactersToUInt(m_data, m_length, ok); +} - // Allow digits. - for (; i != m_length; ++i) - if (!Unicode::isDigit(m_data[i])) - break; - - return DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toUInt64(ok); +int64_t StringImpl::toInt64(bool* ok) +{ + return charactersToInt64(m_data, m_length, ok); +} + +uint64_t StringImpl::toUInt64(bool* ok) +{ + return charactersToUInt64(m_data, m_length, ok); } double StringImpl::toDouble(bool* ok) { - if (!m_length) { - if (ok) - *ok = false; - return 0; - } - char *end; - CString latin1String = Latin1Encoding().encode(characters(), length()); - double val = kjs_strtod(latin1String.data(), &end); - if (ok) - *ok = end == 0 || *end == '\0'; - return val; + return charactersToDouble(m_data, m_length, ok); } float StringImpl::toFloat(bool* ok) { - // FIXME: This will return ok even when the string fits into a double but not a float. - return narrowPrecisionToFloat(toDouble(ok)); + return charactersToFloat(m_data, m_length, ok); } static bool equal(const UChar* a, const char* b, int length) @@ -657,15 +507,7 @@ int StringImpl::find(const char* chs, int index, bool caseSensitive) int StringImpl::find(UChar c, int start) { - unsigned index = start; - if (index >= m_length ) - return -1; - while(index < m_length) { - if (m_data[index] == c) - return index; - index++; - } - return -1; + return WebCore::find(m_data, m_length, c, start); } int StringImpl::find(StringImpl* str, int index, bool caseSensitive) @@ -726,18 +568,7 @@ int StringImpl::find(StringImpl* str, int index, bool caseSensitive) int StringImpl::reverseFind(UChar c, int index) { - if (index >= (int)m_length || m_length == 0) - return -1; - - if (index < 0) - index += m_length; - while (1) { - if (m_data[index] == c) - return index; - if (index == 0) - return -1; - index--; - } + return WebCore::reverseFind(m_data, m_length, c, index); } int StringImpl::reverseFind(StringImpl* str, int index, bool caseSensitive) @@ -1032,20 +863,28 @@ PassRefPtr<StringImpl> StringImpl::createStrippingNullCharacters(const UChar* ch ASSERT(characters); ASSERT(length); - StringBuffer strippedCopy(length); + // Optimize for the case where there are no Null characters by quickly + // searching for nulls, and then using StringImpl::create, which will + // memcpy the whole buffer. This is faster than assigning character by + // character during the loop. + + // Fast case. int foundNull = 0; - for (unsigned i = 0; i < length; i++) { + for (unsigned i = 0; !foundNull && i < length; i++) { int c = characters[i]; // more efficient than using UChar here (at least on Intel Mac OS) - strippedCopy[i] = c; - foundNull |= ~c; + foundNull |= !c; } if (!foundNull) - return adoptRef(new StringImpl(strippedCopy.release(), length, AdoptBuffer())); + return StringImpl::create(characters, length); + + // Slow case. + StringBuffer strippedCopy(length); unsigned strippedLength = 0; for (unsigned i = 0; i < length; i++) { if (int c = characters[i]) strippedCopy[strippedLength++] = c; } + ASSERT(strippedLength < length); // Only take the slow case when stripping. strippedCopy.shrink(strippedLength); return adopt(strippedCopy); } diff --git a/WebCore/platform/text/StringImpl.h b/WebCore/platform/text/StringImpl.h index dd50b2e..57f64c8 100644 --- a/WebCore/platform/text/StringImpl.h +++ b/WebCore/platform/text/StringImpl.h @@ -22,7 +22,6 @@ #ifndef StringImpl_h #define StringImpl_h -#include <kjs/identifier.h> #include <limits.h> #include <wtf/ASCIICType.h> #include <wtf/Forward.h> @@ -30,7 +29,7 @@ #include <wtf/Vector.h> #include <wtf/unicode/Unicode.h> -#if PLATFORM(CF) +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) typedef const struct __CFString * CFStringRef; #endif @@ -44,11 +43,15 @@ class AtomicString; class StringBuffer; struct CStringTranslator; -struct Length; +struct HashAndCharactersTranslator; struct StringHash; struct UCharBufferTranslator; class StringImpl : public RefCounted<StringImpl> { + friend class AtomicString; + friend struct CStringTranslator; + friend struct HashAndCharactersTranslator; + friend struct UCharBufferTranslator; private: StringImpl(); StringImpl(const UChar*, unsigned length); @@ -83,6 +86,7 @@ public: bool hasTerminatingNullCharacter() { return m_hasTerminatingNullCharacter; } unsigned hash() { if (m_hash == 0) m_hash = computeHash(m_data, m_length); return m_hash; } + unsigned existingHash() const { ASSERT(m_hash); return m_hash; } static unsigned computeHash(const UChar*, unsigned len); static unsigned computeHash(const char*); @@ -95,18 +99,21 @@ public: UChar operator[](unsigned i) { ASSERT(i < m_length); return m_data[i]; } UChar32 characterStartingAt(unsigned); - Length toLength(); - bool containsOnlyWhitespace(); - int toInt(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString - int64_t toInt64(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString - uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage, unlike DeprecatedString + int toIntStrict(bool* ok = 0, int base = 10); + unsigned toUIntStrict(bool* ok = 0, int base = 10); + int64_t toInt64Strict(bool* ok = 0, int base = 10); + uint64_t toUInt64Strict(bool* ok = 0, int base = 10); + + int toInt(bool* ok = 0); // ignores trailing garbage + unsigned toUInt(bool* ok = 0); // ignores trailing garbage + int64_t toInt64(bool* ok = 0); // ignores trailing garbage + uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage + double toDouble(bool* ok = 0); float toFloat(bool* ok = 0); - Length* toCoordsArray(int& len); - Length* toLengthArray(int& len); bool isLower(); PassRefPtr<StringImpl> lower(); PassRefPtr<StringImpl> upper(); @@ -138,7 +145,7 @@ public: WTF::Unicode::Direction defaultWritingDirection(); -#if PLATFORM(CF) +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) CFStringRef createCFString(); #endif #ifdef __OBJC__ @@ -146,10 +153,6 @@ public: #endif private: - friend class AtomicString; - friend struct UCharBufferTranslator; - friend struct CStringTranslator; - unsigned m_length; const UChar* m_data; mutable unsigned m_hash; diff --git a/WebCore/platform/text/TextBreakIteratorICU.cpp b/WebCore/platform/text/TextBreakIteratorICU.cpp index 9fd2d0b..9941f58 100644 --- a/WebCore/platform/text/TextBreakIteratorICU.cpp +++ b/WebCore/platform/text/TextBreakIteratorICU.cpp @@ -25,6 +25,7 @@ #include "TextBreakIteratorInternalICU.h" #include <unicode/ubrk.h> +#include <wtf/Assertions.h> namespace WebCore { @@ -38,6 +39,7 @@ static TextBreakIterator* setUpIterator(bool& createdIterator, TextBreakIterator UErrorCode openStatus = U_ZERO_ERROR; iterator = static_cast<TextBreakIterator*>(ubrk_open(type, currentTextBreakLocaleID(), 0, 0, &openStatus)); createdIterator = true; + ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus); } if (!iterator) return 0; diff --git a/WebCore/platform/text/TextCodec.cpp b/WebCore/platform/text/TextCodec.cpp index 1985c49..4222ee1 100644 --- a/WebCore/platform/text/TextCodec.cpp +++ b/WebCore/platform/text/TextCodec.cpp @@ -28,29 +28,31 @@ #include "TextCodec.h" #include "PlatformString.h" +#include <wtf/StringExtras.h> namespace WebCore { -const UChar BOM = 0xFEFF; - TextCodec::~TextCodec() { } -// We strip BOM characters because they can show up both at the start of content -// and inside content, and we never want them to end up in the decoded text. -void TextCodec::appendOmittingBOM(Vector<UChar>& v, const UChar* characters, size_t length) +int TextCodec::getUnencodableReplacement(unsigned codePoint, UnencodableHandling handling, UnencodableReplacementArray replacement) { - size_t start = 0; - for (size_t i = 0; i != length; ++i) { - if (BOM == characters[i]) { - if (start != i) - v.append(&characters[start], i - start); - start = i + 1; - } + switch (handling) { + case QuestionMarksForUnencodables: + replacement[0] = '?'; + replacement[1] = 0; + return 1; + case EntitiesForUnencodables: + snprintf(replacement, sizeof(UnencodableReplacementArray), "&#%u;", codePoint); + return static_cast<int>(strlen(replacement)); + case URLEncodedEntitiesForUnencodables: + snprintf(replacement, sizeof(UnencodableReplacementArray), "%%26%%23%u%%3B", codePoint); + return static_cast<int>(strlen(replacement)); } - if (start != length) - v.append(&characters[start], length - start); + ASSERT_NOT_REACHED(); + replacement[0] = 0; + return 0; } } // namespace WebCore diff --git a/WebCore/platform/text/TextCodec.h b/WebCore/platform/text/TextCodec.h index 77ffcf4..0a56262 100644 --- a/WebCore/platform/text/TextCodec.h +++ b/WebCore/platform/text/TextCodec.h @@ -32,21 +32,46 @@ #include <wtf/Vector.h> #include <wtf/unicode/Unicode.h> -namespace WebCore { +#include "PlatformString.h" - class CString; - class String; +namespace WebCore { class TextEncoding; + // Specifies what will happen when a character is encountered that is + // not encodable in the character set. + enum UnencodableHandling { + // Substitutes the replacement character "?". + QuestionMarksForUnencodables, + + // Encodes the character as an XML entity. For example, U+06DE + // would be "۞" (0x6DE = 1758 in octal). + EntitiesForUnencodables, + + // Encodes the character as en entity as above, but escaped + // non-alphanumeric characters. This is used in URLs. + // For example, U+6DE would be "%26%231758%3B". + URLEncodedEntitiesForUnencodables, + }; + + typedef char UnencodableReplacementArray[32]; + class TextCodec : Noncopyable { public: virtual ~TextCodec(); - virtual String decode(const char*, size_t length, bool flush = false) = 0; - virtual CString encode(const UChar*, size_t length, bool allowEntities = false) = 0; + String decode(const char* str, size_t length, bool flush = false) + { + bool ignored; + return decode(str, length, flush, false, ignored); + } + + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError) = 0; + virtual CString encode(const UChar*, size_t length, UnencodableHandling) = 0; - protected: - static void appendOmittingBOM(Vector<UChar>&, const UChar*, size_t length); + // Fills a null-terminated string representation of the given + // unencodable character into the given replacement buffer. + // The length of the string (not including the null) will be returned. + static int getUnencodableReplacement(unsigned codePoint, UnencodableHandling, UnencodableReplacementArray); }; typedef void (*EncodingNameRegistrar)(const char* alias, const char* name); diff --git a/WebCore/platform/text/TextCodecICU.cpp b/WebCore/platform/text/TextCodecICU.cpp index a89a74e..0a324a2 100644 --- a/WebCore/platform/text/TextCodecICU.cpp +++ b/WebCore/platform/text/TextCodecICU.cpp @@ -33,7 +33,7 @@ #include <unicode/ucnv.h> #include <unicode/ucnv_cb.h> #include <wtf/Assertions.h> -#include <wtf/HashMap.h> +#include <wtf/StringExtras.h> using std::auto_ptr; using std::min; @@ -41,7 +41,7 @@ using std::min; namespace WebCore { const size_t ConversionBufferSize = 16384; - + static UConverter* cachedConverterICU; static auto_ptr<TextCodec> newTextCodecICU(const TextEncoding& encoding, const void*) @@ -60,8 +60,7 @@ void TextCodecICU::registerBaseCodecs(TextCodecRegistrar registrar) } // FIXME: Registering all the encodings we get from ucnv_getAvailableName -// includes encodings we don't want or need. For example: UTF16_PlatformEndian, -// UTF16_OppositeEndian, UTF32_PlatformEndian, UTF32_OppositeEndian, and all +// includes encodings we don't want or need. For example, all // the encodings with commas and version numbers. void TextCodecICU::registerExtendedEncodingNames(EncodingNameRegistrar registrar) @@ -69,27 +68,41 @@ void TextCodecICU::registerExtendedEncodingNames(EncodingNameRegistrar registrar // We register Hebrew with logical ordering using a separate name. // Otherwise, this would share the same canonical name as the // visual ordering case, and then TextEncoding could not tell them - // apart; ICU works with either name. + // apart; ICU treats these names as synonyms. registrar("ISO-8859-8-I", "ISO-8859-8-I"); int32_t numEncodings = ucnv_countAvailable(); for (int32_t i = 0; i < numEncodings; ++i) { const char* name = ucnv_getAvailableName(i); UErrorCode error = U_ZERO_ERROR; - // FIXME: Should we use the "MIME" standard instead of "IANA"? - const char* standardName = ucnv_getStandardName(name, "IANA", &error); - if (!U_SUCCESS(error) || !standardName) - continue; + // Try MIME before trying IANA to pick up commonly used names like + // 'EUC-JP' instead of horrendeously long names like + // 'Extended_UNIX_Code_Packed_Format_for_Japanese'. + const char* standardName = ucnv_getStandardName(name, "MIME", &error); + if (!U_SUCCESS(error) || !standardName) { + error = U_ZERO_ERROR; + // Try IANA to pick up 'windows-12xx' and other names + // which are not preferred MIME names but are widely used. + standardName = ucnv_getStandardName(name, "IANA", &error); + if (!U_SUCCESS(error) || !standardName) + continue; + } // 1. Treat GB2312 encoding as GBK (its more modern superset), to match other browsers. // 2. On the Web, GB2312 is encoded as EUC-CN or HZ, while ICU provides a native encoding // for encoding GB_2312-80 and several others. So, we need to override this behavior, too. if (strcmp(standardName, "GB2312") == 0 || strcmp(standardName, "GB_2312-80") == 0) standardName = "GBK"; -#ifndef ANDROID - else -#endif - registrar(standardName, standardName); + // Similarly, EUC-KR encodings all map to an extended version. + else if (strcmp(standardName, "KSC_5601") == 0 || strcmp(standardName, "EUC-KR") == 0 || strcmp(standardName, "cp1363") == 0) + standardName = "windows-949-2000"; + // And so on. + else if (strcasecmp(standardName, "iso-8859-9") == 0) // This name is returned in different case by ICU 3.2 and 3.6. + standardName = "windows-1254"; + else if (strcmp(standardName, "TIS-620") == 0) + standardName = "windows-874-2000"; + + registrar(standardName, standardName); uint16_t numAliases = ucnv_countAliases(name, &error); ASSERT(U_SUCCESS(error)); @@ -104,21 +117,25 @@ void TextCodecICU::registerExtendedEncodingNames(EncodingNameRegistrar registrar } // Additional aliases. - // Perhaps we can get these added to ICU. + // These are present in modern versions of ICU, but not in ICU 3.2 (shipped with Mac OS X 10.4). registrar("macroman", "macintosh"); - registrar("xmacroman", "macintosh"); +#ifndef ANDROID // Android does not have x-mac-cyrillic in its ICU library + registrar("maccyrillic", "x-mac-cyrillic"); +#endif // Additional aliases that historically were present in the encoding // table in WebKit on Macintosh that don't seem to be present in ICU. // Perhaps we can prove these are not used on the web and remove them. // Or perhaps we can get them added to ICU. + registrar("xmacroman", "macintosh"); +#ifndef ANDROID // Android does not have x-mac-cyrillic in its ICU library + registrar("xmacukrainian", "x-mac-cyrillic"); +#endif registrar("cnbig5", "Big5"); registrar("cngb", "EUC-CN"); registrar("csISO88598I", "ISO_8859-8-I"); registrar("csgb231280", "EUC-CN"); - registrar("dos720", "cp864"); registrar("dos874", "cp874"); - registrar("jis7", "ISO-2022-JP"); registrar("koi", "KOI8-R"); registrar("logical", "ISO-8859-8-I"); registrar("unicode11utf8", "UTF-8"); @@ -127,7 +144,7 @@ void TextCodecICU::registerExtendedEncodingNames(EncodingNameRegistrar registrar registrar("winarabic", "windows-1256"); registrar("winbaltic", "windows-1257"); registrar("wincyrillic", "windows-1251"); - registrar("windows874", "cp874"); + registrar("iso885911", "windows874-2000"); registrar("wingreek", "windows-1253"); registrar("winhebrew", "windows-1255"); registrar("winlatin2", "windows-1250"); @@ -139,7 +156,17 @@ void TextCodecICU::registerExtendedEncodingNames(EncodingNameRegistrar registrar registrar("xeuccn", "EUC-CN"); registrar("xgbk", "EUC-CN"); registrar("xunicode20utf8", "UTF-8"); + registrar("xwindows949", "windows-949-2000"); registrar("xxbig5", "Big5"); + + // This alias is present in modern versions of ICU, but it has no standard name, + // so we give one to it manually. It is not present in ICU 3.2. + registrar("windows874", "windows874-2000"); + + // These aliases are present in modern versions of ICU, but use different codecs, and have no standard names. + // They are not present in ICU 3.2. + registrar("dos720", "cp864"); + registrar("jis7", "ISO-2022-JP"); } void TextCodecICU::registerExtendedCodecs(TextCodecRegistrar registrar) @@ -151,10 +178,13 @@ void TextCodecICU::registerExtendedCodecs(TextCodecRegistrar registrar) for (int32_t i = 0; i < numEncodings; ++i) { const char* name = ucnv_getAvailableName(i); UErrorCode error = U_ZERO_ERROR; - // FIXME: Should we use the "MIME" standard instead of "IANA"? - const char* standardName = ucnv_getStandardName(name, "IANA", &error); - if (!U_SUCCESS(error) || !standardName) - continue; + const char* standardName = ucnv_getStandardName(name, "MIME", &error); + if (!U_SUCCESS(error) || !standardName) { + error = U_ZERO_ERROR; + standardName = ucnv_getStandardName(name, "IANA", &error); + if (!U_SUCCESS(error) || !standardName) + continue; + } registrar(standardName, newTextCodecICU, 0); } } @@ -211,7 +241,50 @@ void TextCodecICU::createICUConverter() const ucnv_setFallback(m_converterICU, TRUE); } -String TextCodecICU::decode(const char* bytes, size_t length, bool flush) +int TextCodecICU::decodeToBuffer(UChar* target, UChar* targetLimit, const char*& source, const char* sourceLimit, int32_t* offsets, bool flush, UErrorCode& err) +{ + UChar* targetStart = target; + err = U_ZERO_ERROR; + ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err); + return target - targetStart; +} + +class ErrorCallbackSetter { +public: + ErrorCallbackSetter(UConverter* converter, bool stopOnError) + : m_converter(converter) + , m_shouldStopOnEncodingErrors(stopOnError) + { + if (m_shouldStopOnEncodingErrors) { + UErrorCode err = U_ZERO_ERROR; + ucnv_setToUCallBack(m_converter, UCNV_TO_U_CALLBACK_SUBSTITUTE, + UCNV_SUB_STOP_ON_ILLEGAL, &m_savedAction, + &m_savedContext, &err); + ASSERT(err == U_ZERO_ERROR); + } + } + ~ErrorCallbackSetter() + { + if (m_shouldStopOnEncodingErrors) { + UErrorCode err = U_ZERO_ERROR; + const void* oldContext; + UConverterToUCallback oldAction; + ucnv_setToUCallBack(m_converter, m_savedAction, + m_savedContext, &oldAction, + &oldContext, &err); + ASSERT(oldAction == UCNV_TO_U_CALLBACK_SUBSTITUTE); + ASSERT(!strcmp(static_cast<const char*>(oldContext), UCNV_SUB_STOP_ON_ILLEGAL)); + ASSERT(err == U_ZERO_ERROR); + } + } +private: + UConverter* m_converter; + bool m_shouldStopOnEncodingErrors; + const void* m_savedContext; + UConverterToUCallback m_savedAction; +}; + +String TextCodecICU::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError) { // Get a converter for the passed-in encoding. if (!m_converterICU) { @@ -222,34 +295,29 @@ String TextCodecICU::decode(const char* bytes, size_t length, bool flush) return String(); } } + + ErrorCallbackSetter callbackSetter(m_converterICU, stopOnError); Vector<UChar> result; UChar buffer[ConversionBufferSize]; + UChar* bufferLimit = buffer + ConversionBufferSize; const char* source = reinterpret_cast<const char*>(bytes); const char* sourceLimit = source + length; int32_t* offsets = NULL; - UErrorCode err; + UErrorCode err = U_ZERO_ERROR; do { - UChar* target = buffer; - const UChar* targetLimit = target + ConversionBufferSize; - err = U_ZERO_ERROR; - ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err); - int count = target - buffer; - appendOmittingBOM(result, reinterpret_cast<const UChar*>(buffer), count); + int ucharsDecoded = decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, flush, err); + result.append(buffer, ucharsDecoded); } while (err == U_BUFFER_OVERFLOW_ERROR); if (U_FAILURE(err)) { // flush the converter so it can be reused, and not be bothered by this error. do { - UChar *target = buffer; - const UChar *targetLimit = target + ConversionBufferSize; - err = U_ZERO_ERROR; - ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, true, &err); + decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, true, err); } while (source < sourceLimit); - LOG_ERROR("ICU conversion error"); - return String(); + sawError = true; } String resultString = String::adopt(result); @@ -265,23 +333,43 @@ String TextCodecICU::decode(const char* bytes, size_t length, bool flush) // We need to apply these fallbacks ourselves as they are not currently supported by ICU and // they were provided by the old TEC encoding path // Needed to fix <rdar://problem/4708689> -static HashMap<UChar32, UChar>& gbkEscapes() { - static HashMap<UChar32, UChar> escapes; - if (escapes.isEmpty()) { - escapes.add(0x01F9, 0xE7C8); - escapes.add(0x1E3F, 0xE7C7); - escapes.add(0x22EF, 0x2026); - escapes.add(0x301C, 0xFF5E); +static UChar getGbkEscape(UChar32 codePoint) +{ + switch (codePoint) { + case 0x01F9: + return 0xE7C8; + case 0x1E3F: + return 0xE7C7; + case 0x22EF: + return 0x2026; + case 0x301C: + return 0xFF5E; + default: + return 0; } - - return escapes; } +// Invalid character handler when writing escaped entities for unrepresentable +// characters. See the declaration of TextCodec::encode for more. +static void urlEscapedEntityCallback(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length, + UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) +{ + if (reason == UCNV_UNASSIGNED) { + *err = U_ZERO_ERROR; + + UnencodableReplacementArray entity; + int entityLen = TextCodec::getUnencodableReplacement(codePoint, URLEncodedEntitiesForUnencodables, entity); + ucnv_cbFromUWriteBytes(fromUArgs, entity, entityLen, 0, err); + } else + UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err); +} + +// Substitutes special GBK characters, escaping all other unassigned entities. static void gbkCallbackEscape(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length, UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) { - if (codePoint && gbkEscapes().contains(codePoint)) { - UChar outChar = gbkEscapes().get(codePoint); + UChar outChar; + if (reason == UCNV_UNASSIGNED && (outChar = getGbkEscape(codePoint))) { const UChar* source = &outChar; *err = U_ZERO_ERROR; ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err); @@ -290,11 +378,28 @@ static void gbkCallbackEscape(const void* context, UConverterFromUnicodeArgs* fr UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err); } +// Combines both gbkUrlEscapedEntityCallback and GBK character substitution. +static void gbkUrlEscapedEntityCallack(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length, + UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) +{ + if (reason == UCNV_UNASSIGNED) { + if (UChar outChar = getGbkEscape(codePoint)) { + const UChar* source = &outChar; + *err = U_ZERO_ERROR; + ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err); + return; + } + urlEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint, reason, err); + return; + } + UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err); +} + static void gbkCallbackSubstitute(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length, UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) { - if (gbkEscapes().contains(codePoint)) { - UChar outChar = gbkEscapes().get(codePoint); + UChar outChar; + if (reason == UCNV_UNASSIGNED && (outChar = getGbkEscape(codePoint))) { const UChar* source = &outChar; *err = U_ZERO_ERROR; ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err); @@ -303,7 +408,7 @@ static void gbkCallbackSubstitute(const void* context, UConverterFromUnicodeArgs UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, fromUArgs, codeUnits, length, codePoint, reason, err); } -CString TextCodecICU::encode(const UChar* characters, size_t length, bool allowEntities) +CString TextCodecICU::encode(const UChar* characters, size_t length, UnencodableHandling handling) { if (!length) return ""; @@ -321,14 +426,20 @@ CString TextCodecICU::encode(const UChar* characters, size_t length, bool allowE const UChar* source = copy.characters(); const UChar* sourceLimit = source + copy.length(); - + UErrorCode err = U_ZERO_ERROR; - if (allowEntities) - ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err); - else { - ucnv_setSubstChars(m_converterICU, "?", 1, &err); - ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err); + switch (handling) { + case QuestionMarksForUnencodables: + ucnv_setSubstChars(m_converterICU, "?", 1, &err); + ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err); + break; + case EntitiesForUnencodables: + ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err); + break; + case URLEncodedEntitiesForUnencodables: + ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err); + break; } ASSERT(U_SUCCESS(err)); diff --git a/WebCore/platform/text/TextCodecICU.h b/WebCore/platform/text/TextCodecICU.h index c2a30b1..9c9a4a7b 100644 --- a/WebCore/platform/text/TextCodecICU.h +++ b/WebCore/platform/text/TextCodecICU.h @@ -45,18 +45,21 @@ namespace WebCore { TextCodecICU(const TextEncoding&); virtual ~TextCodecICU(); - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); private: void createICUConverter() const; void releaseICUConverter() const; bool needsGBKFallbacks() const { return m_needsGBKFallbacks; } - void setNeedsGBKFallbacks(bool needsFallbacks) { m_needsGBKFallbacks = needsFallbacks; } + void setNeedsGBKFallbacks(bool needsFallbacks) { m_needsGBKFallbacks = needsFallbacks; } + + int decodeToBuffer(UChar* buffer, UChar* bufferLimit, const char*& source, + const char* sourceLimit, int32_t* offsets, bool flush, UErrorCode& err); TextEncoding m_encoding; unsigned m_numBufferedBytes; - unsigned char m_bufferedBytes[16]; // bigger than any single multi-byte character + unsigned char m_bufferedBytes[16]; // bigger than any single multi-byte character mutable UConverter* m_converterICU; mutable bool m_needsGBKFallbacks; }; diff --git a/WebCore/platform/text/TextCodecLatin1.cpp b/WebCore/platform/text/TextCodecLatin1.cpp index a687235..50f9f97 100644 --- a/WebCore/platform/text/TextCodecLatin1.cpp +++ b/WebCore/platform/text/TextCodecLatin1.cpp @@ -29,6 +29,7 @@ #include "CString.h" #include "PlatformString.h" #include "StringBuffer.h" +#include <stdio.h> using std::auto_ptr; @@ -117,7 +118,7 @@ void TextCodecLatin1::registerCodecs(TextCodecRegistrar registrar) registrar("US-ASCII", newStreamingTextDecoderWindowsLatin1, 0); } -String TextCodecLatin1::decode(const char* bytes, size_t length, bool) +String TextCodecLatin1::decode(const char* bytes, size_t length, bool, bool, bool&) { StringBuffer characters(length); @@ -141,7 +142,7 @@ String TextCodecLatin1::decode(const char* bytes, size_t length, bool) return String::adopt(characters); } -static CString encodeComplexWindowsLatin1(const UChar* characters, size_t length, bool allowEntities) +static CString encodeComplexWindowsLatin1(const UChar* characters, size_t length, UnencodableHandling handling) { Vector<char> result(length); char* bytes = result.data(); @@ -158,17 +159,13 @@ static CString encodeComplexWindowsLatin1(const UChar* characters, size_t length if (table[b] == c) goto gotByte; // No way to encode this character with Windows Latin-1. - if (allowEntities) { - char entityBuffer[16]; - sprintf(entityBuffer, "&#%u;", c); - size_t entityLength = strlen(entityBuffer); - result.grow(resultLength + entityLength + length - i); - bytes = result.data(); - memcpy(bytes + resultLength, entityBuffer, entityLength); - resultLength += entityLength; - continue; - } - b = '?'; + UnencodableReplacementArray replacement; + int replacementLength = TextCodec::getUnencodableReplacement(c, handling, replacement); + result.grow(resultLength + replacementLength + length - i); + bytes = result.data(); + memcpy(bytes + resultLength, replacement, replacementLength); + resultLength += replacementLength; + continue; } gotByte: bytes[resultLength++] = b; @@ -177,7 +174,7 @@ static CString encodeComplexWindowsLatin1(const UChar* characters, size_t length return CString(bytes, resultLength); } -CString TextCodecLatin1::encode(const UChar* characters, size_t length, bool allowEntities) +CString TextCodecLatin1::encode(const UChar* characters, size_t length, UnencodableHandling handling) { { char* bytes; @@ -196,7 +193,7 @@ CString TextCodecLatin1::encode(const UChar* characters, size_t length, bool all } // If it wasn't all ASCII, call the function that handles more-complex cases. - return encodeComplexWindowsLatin1(characters, length, allowEntities); + return encodeComplexWindowsLatin1(characters, length, handling); } } // namespace WebCore diff --git a/WebCore/platform/text/TextCodecLatin1.h b/WebCore/platform/text/TextCodecLatin1.h index 46d6e66..f035d01 100644 --- a/WebCore/platform/text/TextCodecLatin1.h +++ b/WebCore/platform/text/TextCodecLatin1.h @@ -35,8 +35,8 @@ namespace WebCore { static void registerEncodingNames(EncodingNameRegistrar); static void registerCodecs(TextCodecRegistrar); - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); }; } // namespace WebCore diff --git a/WebCore/platform/text/TextCodecUTF16.cpp b/WebCore/platform/text/TextCodecUTF16.cpp index 9ecd2a9..88e4e73 100644 --- a/WebCore/platform/text/TextCodecUTF16.cpp +++ b/WebCore/platform/text/TextCodecUTF16.cpp @@ -34,8 +34,6 @@ using std::auto_ptr; namespace WebCore { -const UChar BOM = 0xFEFF; - void TextCodecUTF16::registerEncodingNames(EncodingNameRegistrar registrar) { registrar("UTF-16LE", "UTF-16LE"); @@ -67,7 +65,7 @@ void TextCodecUTF16::registerCodecs(TextCodecRegistrar registrar) registrar("UTF-16BE", newStreamingTextDecoderUTF16BE, 0); } -String TextCodecUTF16::decode(const char* bytes, size_t length, bool) +String TextCodecUTF16::decode(const char* bytes, size_t length, bool, bool stopOnError, bool& sawError) { if (!length) return String(); @@ -85,8 +83,7 @@ String TextCodecUTF16::decode(const char* bytes, size_t length, bool) c = m_bufferedByte | (p[0] << 8); else c = (m_bufferedByte << 8) | p[0]; - if (c != BOM) - *q++ = c; + *q++ = c; m_haveBufferedByte = false; p += 1; numChars -= 1; @@ -96,15 +93,13 @@ String TextCodecUTF16::decode(const char* bytes, size_t length, bool) for (size_t i = 0; i < numChars; ++i) { UChar c = p[0] | (p[1] << 8); p += 2; - if (c != BOM) - *q++ = c; + *q++ = c; } else for (size_t i = 0; i < numChars; ++i) { UChar c = (p[0] << 8) | p[1]; p += 2; - if (c != BOM) - *q++ = c; + *q++ = c; } if (numBytes & 1) { @@ -118,7 +113,7 @@ String TextCodecUTF16::decode(const char* bytes, size_t length, bool) return String::adopt(buffer); } -CString TextCodecUTF16::encode(const UChar* characters, size_t length, bool) +CString TextCodecUTF16::encode(const UChar* characters, size_t length, UnencodableHandling) { char* bytes; CString string = CString::newUninitialized(length * 2, bytes); diff --git a/WebCore/platform/text/TextCodecUTF16.h b/WebCore/platform/text/TextCodecUTF16.h index 2bde221..8ce9476 100644 --- a/WebCore/platform/text/TextCodecUTF16.h +++ b/WebCore/platform/text/TextCodecUTF16.h @@ -37,8 +37,8 @@ namespace WebCore { TextCodecUTF16(bool littleEndian) : m_littleEndian(littleEndian), m_haveBufferedByte(false) { } - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); private: bool m_littleEndian; diff --git a/WebCore/platform/text/TextCodecUserDefined.cpp b/WebCore/platform/text/TextCodecUserDefined.cpp index a420992..2dae0f3 100644 --- a/WebCore/platform/text/TextCodecUserDefined.cpp +++ b/WebCore/platform/text/TextCodecUserDefined.cpp @@ -29,6 +29,7 @@ #include "CString.h" #include "PlatformString.h" #include "StringBuffer.h" +#include <stdio.h> using std::auto_ptr; @@ -49,7 +50,7 @@ void TextCodecUserDefined::registerCodecs(TextCodecRegistrar registrar) registrar("x-user-defined", newStreamingTextDecoderUserDefined, 0); } -String TextCodecUserDefined::decode(const char* bytes, size_t length, bool) +String TextCodecUserDefined::decode(const char* bytes, size_t length, bool, bool, bool&) { StringBuffer buffer(length); @@ -61,7 +62,7 @@ String TextCodecUserDefined::decode(const char* bytes, size_t length, bool) return String::adopt(buffer); } -static CString encodeComplexUserDefined(const UChar* characters, size_t length, bool allowEntities) +static CString encodeComplexUserDefined(const UChar* characters, size_t length, UnencodableHandling handling) { Vector<char> result(length); char* bytes = result.data(); @@ -71,27 +72,23 @@ static CString encodeComplexUserDefined(const UChar* characters, size_t length, UChar32 c; U16_NEXT(characters, i, length, c); signed char signedByte = c; - if ((signedByte & 0xf7ff) == c) + if ((signedByte & 0xF7FF) == c) bytes[resultLength++] = signedByte; else { // No way to encode this character with x-user-defined. - if (allowEntities) { - char entityBuffer[16]; - sprintf(entityBuffer, "&#%u;", c); - size_t entityLength = strlen(entityBuffer); - result.grow(resultLength + entityLength + length - i); - bytes = result.data(); - memcpy(bytes + resultLength, entityBuffer, entityLength); - resultLength += entityLength; - } else - bytes[resultLength++] = '?'; + UnencodableReplacementArray replacement; + int replacementLength = TextCodec::getUnencodableReplacement(c, handling, replacement); + result.grow(resultLength + replacementLength + length - i); + bytes = result.data(); + memcpy(bytes + resultLength, replacement, replacementLength); + resultLength += replacementLength; } } return CString(bytes, resultLength); } -CString TextCodecUserDefined::encode(const UChar* characters, size_t length, bool allowEntities) +CString TextCodecUserDefined::encode(const UChar* characters, size_t length, UnencodableHandling handling) { char* bytes; CString string = CString::newUninitialized(length, bytes); @@ -108,7 +105,7 @@ CString TextCodecUserDefined::encode(const UChar* characters, size_t length, boo return string; // If it wasn't all ASCII, call the function that handles more-complex cases. - return encodeComplexUserDefined(characters, length, allowEntities); + return encodeComplexUserDefined(characters, length, handling); } } // namespace WebCore diff --git a/WebCore/platform/text/TextCodecUserDefined.h b/WebCore/platform/text/TextCodecUserDefined.h index 4fba907..d1b3160 100644 --- a/WebCore/platform/text/TextCodecUserDefined.h +++ b/WebCore/platform/text/TextCodecUserDefined.h @@ -35,8 +35,8 @@ namespace WebCore { static void registerEncodingNames(EncodingNameRegistrar); static void registerCodecs(TextCodecRegistrar); - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); }; } // namespace WebCore diff --git a/WebCore/platform/text/TextDecoder.cpp b/WebCore/platform/text/TextDecoder.cpp index 8633e9f..e39a6b7 100644 --- a/WebCore/platform/text/TextDecoder.cpp +++ b/WebCore/platform/text/TextDecoder.cpp @@ -47,8 +47,10 @@ void TextDecoder::reset(const TextEncoding& encoding) m_numBufferedBytes = 0; } -String TextDecoder::checkForBOM(const char* data, size_t length, bool flush) +String TextDecoder::checkForBOM(const char* data, size_t length, bool flush, bool stopOnError, bool& sawError) { + ASSERT(!m_checkedForBOM); + // Check to see if we found a BOM. size_t numBufferedBytes = m_numBufferedBytes; size_t buf1Len = numBufferedBytes; @@ -62,22 +64,28 @@ String TextDecoder::checkForBOM(const char* data, size_t length, bool flush) const TextEncoding* encodingConsideringBOM = &m_encoding; bool foundBOM = true; + size_t lengthOfBOM = 0; if (c1 == 0xFF && c2 == 0xFE) { - if (c3 != 0 || c4 != 0) + if (c3 != 0 || c4 != 0) { encodingConsideringBOM = &UTF16LittleEndianEncoding(); - else if (numBufferedBytes + length > sizeof(m_bufferedBytes)) + lengthOfBOM = 2; + } else if (numBufferedBytes + length > sizeof(m_bufferedBytes)) { encodingConsideringBOM = &UTF32LittleEndianEncoding(); - else + lengthOfBOM = 4; + } else foundBOM = false; - } - else if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) + } else if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) { encodingConsideringBOM = &UTF8Encoding(); - else if (c1 == 0xFE && c2 == 0xFF) + lengthOfBOM = 3; + } else if (c1 == 0xFE && c2 == 0xFF) { encodingConsideringBOM = &UTF16BigEndianEncoding(); - else if (c1 == 0 && c2 == 0 && c3 == 0xFE && c4 == 0xFF) + lengthOfBOM = 2; + } else if (c1 == 0 && c2 == 0 && c3 == 0xFE && c4 == 0xFF) { encodingConsideringBOM = &UTF32BigEndianEncoding(); - else + lengthOfBOM = 4; + } else foundBOM = false; + if (!foundBOM && numBufferedBytes + length <= sizeof(m_bufferedBytes) && !flush) { // Continue to look for the BOM. memcpy(&m_bufferedBytes[numBufferedBytes], data, length); @@ -91,16 +99,31 @@ String TextDecoder::checkForBOM(const char* data, size_t length, bool flush) return String(); m_checkedForBOM = true; + // Skip the BOM. + if (foundBOM) { + ASSERT(numBufferedBytes < lengthOfBOM); + size_t numUnbufferedBOMBytes = lengthOfBOM - numBufferedBytes; + ASSERT(numUnbufferedBOMBytes <= length); + + data += numUnbufferedBOMBytes; + length -= numUnbufferedBOMBytes; + numBufferedBytes = 0; + m_numBufferedBytes = 0; + } + // Handle case where we have some buffered bytes to deal with. if (numBufferedBytes) { char bufferedBytes[sizeof(m_bufferedBytes)]; memcpy(bufferedBytes, m_bufferedBytes, numBufferedBytes); m_numBufferedBytes = 0; - return m_codec->decode(bufferedBytes, numBufferedBytes, false) - + m_codec->decode(data, length, flush); + + String bufferedResult = m_codec->decode(bufferedBytes, numBufferedBytes, false, stopOnError, sawError); + if (stopOnError && sawError) + return bufferedResult; + return bufferedResult + m_codec->decode(data, length, flush, stopOnError, sawError); } - return m_codec->decode(data, length, flush); + return m_codec->decode(data, length, flush, stopOnError, sawError); } } // namespace WebCore diff --git a/WebCore/platform/text/TextDecoder.h b/WebCore/platform/text/TextDecoder.h index 3892032..171cb59 100644 --- a/WebCore/platform/text/TextDecoder.h +++ b/WebCore/platform/text/TextDecoder.h @@ -41,15 +41,15 @@ namespace WebCore { void reset(const TextEncoding&); const TextEncoding& encoding() const { return m_encoding; }; - String decode(const char* data, size_t length, bool flush = false) + String decode(const char* data, size_t length, bool flush, bool stopOnError, bool& sawError) { if (!m_checkedForBOM) - return checkForBOM(data, length, flush); - return m_codec->decode(data, length, flush); + return checkForBOM(data, length, flush, stopOnError, sawError); + return m_codec->decode(data, length, flush, stopOnError, sawError); } private: - String checkForBOM(const char*, size_t length, bool flush); + String checkForBOM(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); TextEncoding m_encoding; OwnPtr<TextCodec> m_codec; diff --git a/WebCore/platform/text/TextEncoding.cpp b/WebCore/platform/text/TextEncoding.cpp index c7676e9..9026049 100644 --- a/WebCore/platform/text/TextEncoding.cpp +++ b/WebCore/platform/text/TextEncoding.cpp @@ -59,15 +59,15 @@ TextEncoding::TextEncoding(const String& name) { } -String TextEncoding::decode(const char* data, size_t length) const +String TextEncoding::decode(const char* data, size_t length, bool stopOnError, bool& sawError) const { if (!m_name) return String(); - return TextDecoder(*this).decode(data, length, true); + return TextDecoder(*this).decode(data, length, true, stopOnError, sawError); } -CString TextEncoding::encode(const UChar* characters, size_t length, bool allowEntities) const +CString TextEncoding::encode(const UChar* characters, size_t length, UnencodableHandling handling) const { if (!m_name) return CString(); @@ -100,11 +100,11 @@ CString TextEncoding::encode(const UChar* characters, size_t length, bool allowE source = normalizedCharacters.data(); sourceLength = normalizedLength; } - return newTextCodec(*this)->encode(source, sourceLength, allowEntities); + return newTextCodec(*this)->encode(source, sourceLength, handling); #elif USE(QT4_UNICODE) QString str(reinterpret_cast<const QChar*>(characters), length); str = str.normalized(QString::NormalizationForm_C); - return newTextCodec(*this)->encode(reinterpret_cast<const UChar *>(str.utf16()), str.length(), allowEntities); + return newTextCodec(*this)->encode(reinterpret_cast<const UChar *>(str.utf16()), str.length(), handling); #endif } diff --git a/WebCore/platform/text/TextEncoding.h b/WebCore/platform/text/TextEncoding.h index 59d225c..0a0ab8c 100644 --- a/WebCore/platform/text/TextEncoding.h +++ b/WebCore/platform/text/TextEncoding.h @@ -26,6 +26,7 @@ #ifndef TextEncoding_h #define TextEncoding_h +#include "TextCodec.h" #include <wtf/unicode/Unicode.h> namespace WebCore { @@ -46,8 +47,13 @@ namespace WebCore { UChar backslashAsCurrencySymbol() const; const TextEncoding& closest8BitEquivalent() const; - String decode(const char*, size_t length) const; - CString encode(const UChar*, size_t length, bool allowEntities = false) const; + String decode(const char* str, size_t length) const + { + bool ignored; + return decode(str, length, false, ignored); + } + String decode(const char*, size_t length, bool stopOnError, bool& sawError) const; + CString encode(const UChar*, size_t length, UnencodableHandling) const; private: const char* m_name; diff --git a/WebCore/platform/text/TextEncodingRegistry.cpp b/WebCore/platform/text/TextEncodingRegistry.cpp index a7ad879..3f1f078 100644 --- a/WebCore/platform/text/TextEncodingRegistry.cpp +++ b/WebCore/platform/text/TextEncodingRegistry.cpp @@ -33,6 +33,7 @@ #include <wtf/ASCIICType.h> #include <wtf/Assertions.h> #include <wtf/HashMap.h> +#include <wtf/StringExtras.h> #if USE(ICU_UNICODE) #include "TextCodecICU.h" @@ -132,7 +133,7 @@ static void checkExistingName(const char* alias, const char* atomicName) // Keep the warning silent about one case where we know this will happen. if (strcmp(alias, "ISO-8859-8-I") == 0 && strcmp(oldAtomicName, "ISO-8859-8-I") == 0 - && strcmp(atomicName, "ISO_8859-8:1988") == 0) + && strcasecmp(atomicName, "iso-8859-8") == 0) return; LOG_ERROR("alias %s maps to %s already, but someone is trying to make it map to %s", alias, oldAtomicName, atomicName); diff --git a/WebCore/platform/text/TextStream.cpp b/WebCore/platform/text/TextStream.cpp index b23e769..5b7a0c7 100644 --- a/WebCore/platform/text/TextStream.cpp +++ b/WebCore/platform/text/TextStream.cpp @@ -26,145 +26,89 @@ #include "config.h" #include "TextStream.h" -#include "DeprecatedString.h" -#include "Logging.h" #include "PlatformString.h" -#include <wtf/Vector.h> +#include <wtf/StringExtras.h> namespace WebCore { -const size_t integerOrPointerAsStringBufferSize = 100; // large enough for any integer or pointer in string format, including trailing null character -const char* const precisionFormats[7] = { "%.0f", "%.1f", "%.2f", "%.3f", "%.4f", "%.5f", "%.6f"}; -const int maxPrecision = 6; // must match size of precisionFormats -const int defaultPrecision = 6; // matches qt and sprintf(.., "%f", ...) behaviour - -TextStream::TextStream(DeprecatedString* s) - : m_hasByteArray(false), m_string(s), m_precision(defaultPrecision) -{ -} - -TextStream& TextStream::operator<<(char c) -{ - if (m_hasByteArray) - m_byteArray.append(c); - - if (m_string) - m_string->append(DeprecatedChar(c)); - return *this; -} - -TextStream& TextStream::operator<<(short i) -{ - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%d", i); - return *this << buffer; -} - -TextStream& TextStream::operator<<(unsigned short i) -{ - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%u", i); - return *this << buffer; -} +static const size_t printBufferSize = 100; // large enough for any integer or floating point value in string format, including trailing null character TextStream& TextStream::operator<<(int i) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%d", i); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%d", i); return *this << buffer; } TextStream& TextStream::operator<<(unsigned i) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%u", i); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%u", i); return *this << buffer; } TextStream& TextStream::operator<<(long i) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%ld", i); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%ld", i); return *this << buffer; } TextStream& TextStream::operator<<(unsigned long i) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%lu", i); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%lu", i); return *this << buffer; } TextStream& TextStream::operator<<(float f) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, precisionFormats[m_precision], f); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%.2f", f); return *this << buffer; } TextStream& TextStream::operator<<(double d) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, precisionFormats[m_precision], d); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%.2f", d); return *this << buffer; } -TextStream& TextStream::operator<<(const char* s) +TextStream& TextStream::operator<<(const char* string) { - if (m_hasByteArray) { - unsigned length = strlen(s); - unsigned oldSize = m_byteArray.size(); - m_byteArray.grow(oldSize + length); - memcpy(m_byteArray.data() + oldSize, s, length); - } - if (m_string) - m_string->append(s); + size_t stringLength = strlen(string); + size_t textLength = m_text.size(); + m_text.grow(textLength + stringLength); + for (size_t i = 0; i < stringLength; ++i) + m_text[textLength + i] = string[i]; return *this; } -TextStream& TextStream::operator<<(const DeprecatedString& s) +TextStream& TextStream::operator<<(const String& string) { - if (m_hasByteArray) { - unsigned length = s.length(); - unsigned oldSize = m_byteArray.size(); - m_byteArray.grow(oldSize + length); - memcpy(m_byteArray.data() + oldSize, s.latin1(), length); - } - if (m_string) - m_string->append(s); + append(m_text, string); return *this; } -TextStream& TextStream::operator<<(const String& s) +String TextStream::release() { - return (*this) << s.deprecatedString(); + return String::adopt(m_text); } -TextStream& TextStream::operator<<(void* p) +#if PLATFORM(WIN_OS) && PLATFORM(X86_64) && COMPILER(MSVC) +TextStream& TextStream::operator<<(__int64 i) { - char buffer[integerOrPointerAsStringBufferSize]; - sprintf(buffer, "%p", p); + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%I64i", i); return *this << buffer; } - -TextStream& TextStream::operator<<(const TextStreamManipulator& m) -{ - return m(*this); -} - -int TextStream::precision(int p) -{ - int oldPrecision = m_precision; - - if (p >= 0 && p <= maxPrecision) - m_precision = p; - - return oldPrecision; -} - -TextStream &endl(TextStream& stream) +TextStream& TextStream::operator<<(unsigned __int64 i) { - return stream << '\n'; + char buffer[printBufferSize]; + snprintf(buffer, sizeof(buffer) - 1, "%I64u", i); + return *this << buffer; } +#endif } diff --git a/WebCore/platform/text/TextStream.h b/WebCore/platform/text/TextStream.h index 897c267..6fb3f4b 100644 --- a/WebCore/platform/text/TextStream.h +++ b/WebCore/platform/text/TextStream.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2004 Apple Computer, Inc. All rights reserved. + * Copyright (C) 2004, 2008 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -27,26 +27,14 @@ #define TextStream_h #include <wtf/Vector.h> +#include <wtf/unicode/Unicode.h> namespace WebCore { -class DeprecatedChar; -class DeprecatedString; class String; -class TextStream; - -typedef TextStream& (*TextStreamManipulator)(TextStream&); - -TextStream& endl(TextStream&); class TextStream { public: - TextStream(DeprecatedString*); - - TextStream& operator<<(char); - TextStream& operator<<(const DeprecatedChar&); - TextStream& operator<<(short); - TextStream& operator<<(unsigned short); TextStream& operator<<(int); TextStream& operator<<(unsigned); TextStream& operator<<(long); @@ -55,21 +43,15 @@ public: TextStream& operator<<(double); TextStream& operator<<(const char*); TextStream& operator<<(const String&); - TextStream& operator<<(const DeprecatedString&); - TextStream& operator<<(void*); - - TextStream& operator<<(const TextStreamManipulator&); +#if PLATFORM(WIN_OS) && PLATFORM(X86_64) && COMPILER(MSVC) + TextStream& operator<<(unsigned __int64); + TextStream& operator<<(__int64); +#endif - int precision(int); + String release(); private: - TextStream(const TextStream&); - TextStream& operator=(const TextStream&); - - bool m_hasByteArray; - Vector<char> m_byteArray; - DeprecatedString* m_string; - int m_precision; + Vector<UChar> m_text; }; } diff --git a/WebCore/platform/text/cf/StringCF.cpp b/WebCore/platform/text/cf/StringCF.cpp index 9e0d5f2..5e12ba9 100644 --- a/WebCore/platform/text/cf/StringCF.cpp +++ b/WebCore/platform/text/cf/StringCF.cpp @@ -21,7 +21,7 @@ #include "config.h" #include "PlatformString.h" -#if PLATFORM(CF) +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) #include <CoreFoundation/CoreFoundation.h> @@ -52,4 +52,4 @@ CFStringRef String::createCFString() const } -#endif // PLATFORM(CF) +#endif // PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) diff --git a/WebCore/platform/text/cf/StringImplCF.cpp b/WebCore/platform/text/cf/StringImplCF.cpp index 21b43df..ff595a5 100644 --- a/WebCore/platform/text/cf/StringImplCF.cpp +++ b/WebCore/platform/text/cf/StringImplCF.cpp @@ -21,7 +21,7 @@ #include "config.h" #include "StringImpl.h" -#if PLATFORM(CF) +#if PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) #include <CoreFoundation/CoreFoundation.h> @@ -34,4 +34,4 @@ CFStringRef StringImpl::createCFString() } -#endif // PLATFORM(CF) +#endif // PLATFORM(CF) || (PLATFORM(QT) && PLATFORM(DARWIN)) diff --git a/WebCore/platform/text/mac/ShapeArabic.c b/WebCore/platform/text/mac/ShapeArabic.c index 4706e7c..6dbc008 100644 --- a/WebCore/platform/text/mac/ShapeArabic.c +++ b/WebCore/platform/text/mac/ShapeArabic.c @@ -2,8 +2,28 @@ ****************************************************************************** * * Copyright (C) 2000-2004, International Business Machines -* Corporation and others. All Rights Reserved. -* Copyright (C) 2007 Apple Inc. All rights reserved. +* Corporation and others. All Rights Reserved. +* Copyright (C) 2007 Apple Inc. All rights reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this +* software and associated documentation files (the "Software"), to deal in the Software +* without restriction, including without limitation the rights to use, copy, modify, +* merge, publish, distribute, and/or sell copies of the Software, and to permit persons +* to whom the Software is furnished to do so, provided that the above copyright notice(s) +* and this permission notice appear in all copies of the Software and that both the above +* copyright notice(s) and this permission notice appear in supporting documentation. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +* PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER +* OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR +* CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR +* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING +* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +* +* Except as contained in this notice, the name of a copyright holder shall not be used in +* advertising or otherwise to promote the sale, use or other dealings in this Software +* without prior written authorization of the copyright holder. * ****************************************************************************** * @@ -11,6 +31,9 @@ */ #include "config.h" + +#if USE(ATSUI) + #include "ShapeArabic.h" #include <unicode/utypes.h> @@ -528,3 +551,5 @@ int32_t shapeArabic(const UChar *source, int32_t sourceLength, UChar *dest, int3 return sourceLength; } + +#endif // USE(ATSUI) diff --git a/WebCore/platform/text/mac/ShapeArabic.h b/WebCore/platform/text/mac/ShapeArabic.h index 2f85ea0..8aa577d 100644 --- a/WebCore/platform/text/mac/ShapeArabic.h +++ b/WebCore/platform/text/mac/ShapeArabic.h @@ -26,6 +26,8 @@ #ifndef ShapeArabic_h #define ShapeArabic_h +#if USE(ATSUI) + #include <unicode/ushape.h> #ifdef __cplusplus @@ -38,4 +40,5 @@ int32_t shapeArabic(const UChar *source, int32_t sourceLength, UChar *dest, int3 } #endif +#endif // USE(ATSUI) #endif // ShapeArabic_h diff --git a/WebCore/platform/text/mac/TextCodecMac.cpp b/WebCore/platform/text/mac/TextCodecMac.cpp index 7270a26..ac1f0fb 100644 --- a/WebCore/platform/text/mac/TextCodecMac.cpp +++ b/WebCore/platform/text/mac/TextCodecMac.cpp @@ -78,7 +78,6 @@ void TextCodecMac::registerCodecs(TextCodecRegistrar registrar) TextCodecMac::TextCodecMac(TECTextEncodingID encoding) : m_encoding(encoding) - , m_error(false) , m_numBufferedBytes(0) , m_converterTEC(0) { @@ -179,16 +178,15 @@ OSStatus TextCodecMac::decode(const unsigned char* inputBuffer, int inputBufferL } // Work around bug 3351093, where sometimes we get kTECBufferBelowMinimumSizeErr instead of kTECOutputBufferFullStatus. - if (status == kTECBufferBelowMinimumSizeErr && bytesWritten != 0) { + if (status == kTECBufferBelowMinimumSizeErr && bytesWritten != 0) status = kTECOutputBufferFullStatus; - } inputLength = bytesRead; outputLength = bytesWritten; return status; } -String TextCodecMac::decode(const char* bytes, size_t length, bool flush) +String TextCodecMac::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError) { // Get a converter for the passed-in encoding. if (!m_converterTEC && createTECConverter() != noErr) @@ -201,7 +199,7 @@ String TextCodecMac::decode(const char* bytes, size_t length, bool flush) bool bufferWasFull = false; UniChar buffer[ConversionBufferSize]; - while (sourceLength || bufferWasFull) { + while ((sourceLength || bufferWasFull) && !sawError) { int bytesRead = 0; int bytesWritten = 0; OSStatus status = decode(sourcePointer, sourceLength, bytesRead, buffer, sizeof(buffer), bytesWritten); @@ -217,6 +215,10 @@ String TextCodecMac::decode(const char* bytes, size_t length, bool flush) case kTextUndefinedElementErr: // FIXME: Put FFFD character into the output string in this case? TECClearConverterContextInfo(m_converterTEC); + if (stopOnError) { + sawError = true; + break; + } if (sourceLength) { sourcePointer += 1; sourceLength -= 1; @@ -236,13 +238,12 @@ String TextCodecMac::decode(const char* bytes, size_t length, bool flush) break; } default: - LOG_ERROR("text decoding failed with error %ld", static_cast<long>(status)); - m_error = true; + sawError = true; return String(); } ASSERT(!(bytesWritten % sizeof(UChar))); - appendOmittingBOM(result, buffer, bytesWritten / sizeof(UChar)); + result.append(buffer, bytesWritten / sizeof(UChar)); bufferWasFull = status == kTECOutputBufferFullStatus; } @@ -251,7 +252,7 @@ String TextCodecMac::decode(const char* bytes, size_t length, bool flush) unsigned long bytesWritten = 0; TECFlushText(m_converterTEC, reinterpret_cast<unsigned char*>(buffer), sizeof(buffer), &bytesWritten); ASSERT(!(bytesWritten % sizeof(UChar))); - appendOmittingBOM(result, buffer, bytesWritten / sizeof(UChar)); + result.append(buffer, bytesWritten / sizeof(UChar)); } String resultString = String::adopt(result); @@ -266,7 +267,7 @@ String TextCodecMac::decode(const char* bytes, size_t length, bool flush) return resultString; } -CString TextCodecMac::encode(const UChar* characters, size_t length, bool allowEntities) +CString TextCodecMac::encode(const UChar* characters, size_t length, UnencodableHandling handling) { // FIXME: We should really use TEC here instead of CFString for consistency with the other direction. @@ -280,7 +281,7 @@ CString TextCodecMac::encode(const UChar* characters, size_t length, bool allowE CFIndex charactersLeft = CFStringGetLength(cfs); Vector<char> result; size_t size = 0; - UInt8 lossByte = allowEntities ? 0 : '?'; + UInt8 lossByte = handling == QuestionMarksForUnencodables ? '?' : 0; while (charactersLeft > 0) { CFRange range = CFRangeMake(startPos, charactersLeft); CFIndex bufferLength; @@ -303,11 +304,10 @@ CString TextCodecMac::encode(const UChar* characters, size_t length, bool allowE ++charactersConverted; } } - char entityBuffer[16]; - sprintf(entityBuffer, "&#%u;", badChar); - size_t entityLength = strlen(entityBuffer); + UnencodableReplacementArray entity; + int entityLength = getUnencodableReplacement(badChar, handling, entity); result.grow(size + entityLength); - memcpy(result.data() + size, entityBuffer, entityLength); + memcpy(result.data() + size, entity, entityLength); size += entityLength; } diff --git a/WebCore/platform/text/mac/TextCodecMac.h b/WebCore/platform/text/mac/TextCodecMac.h index 639e214..aee4a97 100644 --- a/WebCore/platform/text/mac/TextCodecMac.h +++ b/WebCore/platform/text/mac/TextCodecMac.h @@ -43,8 +43,8 @@ namespace WebCore { explicit TextCodecMac(TECTextEncodingID); virtual ~TextCodecMac(); - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); private: OSStatus decode(const unsigned char* inputBuffer, int inputBufferLength, int& inputLength, @@ -55,7 +55,6 @@ namespace WebCore { TECTextEncodingID m_encoding; UChar m_backslashAsCurrencySymbol; - bool m_error; unsigned m_numBufferedBytes; unsigned char m_bufferedBytes[16]; // bigger than any single multi-byte character mutable TECObjectRef m_converterTEC; diff --git a/WebCore/platform/text/mac/mac-encodings.txt b/WebCore/platform/text/mac/mac-encodings.txt index 270c625..bb45e22 100644 --- a/WebCore/platform/text/mac/mac-encodings.txt +++ b/WebCore/platform/text/mac/mac-encodings.txt @@ -22,15 +22,12 @@ JIS_X0208_90: JIS_X0208-1990 JIS_X0212_90: JIS_X0212-1990 KOI8_U: KOI8-U MacArabic: x-mac-arabic -MacCentralEurRoman: x-mac-centraleurroman, xmacce MacChineseSimp: x-mac-chinesesimp, xmacsimpchinese MacChineseTrad: x-mac-chinesetrad, xmactradchinese MacCroatian: x-mac-croatian -MacCyrillic: x-mac-cyrillic, maccyrillic, xmacukrainian MacDevanagari: x-mac-devanagari MacDingbats: x-mac-dingbats MacFarsi: x-mac-farsi -MacGreek: x-mac-greek MacGujarati: x-mac-gujarati MacGurmukhi: x-mac-gurmukhi MacHebrew: x-mac-hebrew @@ -42,7 +39,6 @@ MacRomanian: x-mac-romanian MacSymbol: x-mac-symbol MacThai: x-mac-thai MacTibetan: x-mac-tibetan -MacTurkish: x-mac-turkish MacVT100: x-mac-vt100 NextStepLatin: x-nextstep ShiftJIS_X0213_00: Shift_JIS_X0213-2000 diff --git a/WebCore/platform/text/qt/StringQt.cpp b/WebCore/platform/text/qt/StringQt.cpp index 23a684b..de9f527 100644 --- a/WebCore/platform/text/qt/StringQt.cpp +++ b/WebCore/platform/text/qt/StringQt.cpp @@ -26,7 +26,6 @@ #include "config.h" #include "PlatformString.h" -#include "DeprecatedString.h" #include <QString> @@ -44,21 +43,14 @@ String::String(const QStringRef& ref) { if (!ref.string()) return; - m_impl = StringImpl::create(reinterpret_cast<const UChar *>(ref.unicode()), ref.length()); + m_impl = StringImpl::create(reinterpret_cast<const UChar*>(ref.unicode()), ref.length()); } - String::operator QString() const { return QString(reinterpret_cast<const QChar*>(characters()), length()); } -// DeprecatedString conversions -DeprecatedString::operator QString() const -{ - return QString(reinterpret_cast<const QChar*>(unicode()), length()); -} - } // vim: ts=4 sw=4 et diff --git a/WebCore/platform/text/qt/TextCodecQt.cpp b/WebCore/platform/text/qt/TextCodecQt.cpp index 888c6af..0f385dd 100644 --- a/WebCore/platform/text/qt/TextCodecQt.cpp +++ b/WebCore/platform/text/qt/TextCodecQt.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2006 Lars Knoll <lars@trolltech.com> + * Copyright (C) 2008 Holger Hans Peter Freyther * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -91,9 +92,10 @@ TextCodecQt::~TextCodecQt() } -String TextCodecQt::decode(const char* bytes, size_t length, bool flush) +String TextCodecQt::decode(const char* bytes, size_t length, bool flush, bool /*stopOnError*/, bool& sawError) { QString unicode = m_codec->toUnicode(bytes, length, &m_state); + sawError = m_state.invalidChars != 0; if (flush) { m_state.flags = QTextCodec::DefaultConversion; @@ -104,12 +106,12 @@ String TextCodecQt::decode(const char* bytes, size_t length, bool flush) return unicode; } -CString TextCodecQt::encode(const UChar* characters, size_t length, bool allowEntities) +CString TextCodecQt::encode(const UChar* characters, size_t length, UnencodableHandling) { if (!length) return ""; - // FIXME: do something sensible with allowEntities + // FIXME: do something sensible with UnencodableHandling QByteArray ba = m_codec->fromUnicode(reinterpret_cast<const QChar*>(characters), length, 0); return CString(ba.constData(), ba.length()); diff --git a/WebCore/platform/text/qt/TextCodecQt.h b/WebCore/platform/text/qt/TextCodecQt.h index 9bbb80b..f28f0bb 100644 --- a/WebCore/platform/text/qt/TextCodecQt.h +++ b/WebCore/platform/text/qt/TextCodecQt.h @@ -30,8 +30,6 @@ #include "TextEncoding.h" #include <QTextCodec> -class QTextCodec; - namespace WebCore { class TextCodecQt : public TextCodec { @@ -42,8 +40,8 @@ namespace WebCore { TextCodecQt(const TextEncoding&); virtual ~TextCodecQt(); - virtual String decode(const char*, size_t length, bool flush = false); - virtual CString encode(const UChar*, size_t length, bool allowEntities = false); + virtual String decode(const char*, size_t length, bool flush, bool stopOnError, bool& sawError); + virtual CString encode(const UChar*, size_t length, UnencodableHandling); private: TextEncoding m_encoding; diff --git a/WebCore/platform/text/wx/StringWx.cpp b/WebCore/platform/text/wx/StringWx.cpp index 7f91dbf..50919c4 100644 --- a/WebCore/platform/text/wx/StringWx.cpp +++ b/WebCore/platform/text/wx/StringWx.cpp @@ -27,7 +27,6 @@ #include "PlatformString.h" #include "CString.h" -#include "DeprecatedString.h" #include "unicode/ustring.h" #include <wx/defs.h> @@ -88,12 +87,6 @@ String::operator wxString() const return wxString(utf8().data(), wxConvUTF8); } -// DeprecatedString conversions -DeprecatedString::operator wxString() const -{ - return wxString(utf8().data(), wxConvUTF8); -} - } // vim: ts=4 sw=4 et |