LayoutTests:
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2006 04:59:57 +0000 (04:59 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2006 04:59:57 +0000 (04:59 +0000)
        - test for http://bugzilla.opendarwin.org/show_bug.cgi?id=6310
          text-transform: uppercase/lowercase don't handle cases one character becomes two

        * fast/css/case-transform.html: Added.
        * fast/css/case-transform-expected.txt: Added.

WebCore:

        Rubber stamped by Hyatt.

        - http://bugzilla.opendarwin.org/show_bug.cgi?id=8782
          use ICU and UChar more, QChar less

        - fix http://bugzilla.opendarwin.org/show_bug.cgi?id=6310
          text-transform: uppercase/lowercase don't handle cases one character becomes two

        Test: fast/css/case-transform.html

        By using ICU more, this fixes some bugs in a few places.

        * bindings/js/JSXMLSerializer.cpp:
        * css/css_valueimpl.h:
        * kwq/KWQTextStream.cpp:
        * loader/CachedObject.h:
        * platform/Color.cpp:
        Add includes of DeprecatedString.h as needed, now that StringImpl.h no longer
        includes it.

        * bindings/js/kjs_css.cpp: (KJS::cssPropertyName):
        Eliminate use of QChar::latin1() in a case where it's not helpful.

        * bindings/js/kjs_proxy.cpp: (WebCore::KJSProxy::evaluate):
        Use characters() function instead of the old unicode() function.

        * bindings/js/kjs_window.cpp: (KJS::isSeparator):
        Use UChar instead of QChar.

        * bindings/objc/DOMInternal.mm:
        (StringImpl::operator NSString*): Remove typecast that's no longer needed.
        (String::String): Ditto. Also use Vector for local buffer to make code read simpler.

        * bridge/mac/FrameMac.mm:
        (WebCore::selectorForKeyEvent): Remove call to unicode() function, no longer needed.
        (WebCore::FrameMac::setTitle): Remove QChar cast, no longer needed.
        (WebCore::FrameMac::setStatusBarText): Ditto.
        (WebCore::FrameMac::advanceToNextMisspelling): Use UChar instead of QChar.
        (WebCore::FrameMac::runJavaScriptAlert): Remove QChar cast, no longer needed.
        (WebCore::FrameMac::runJavaScriptConfirm): Ditto.
        (WebCore::FrameMac::runJavaScriptPrompt): Ditto.
        (WebCore::FrameMac::attributedString): Replaces calls of QChar::direction() with
        calls to u_charDirection and use ICU constants instead of QChar ones.
        (WebCore::FrameMac::markMisspellings): Remove QChar cast, no longer needed. Added a
        QChar cast so we can call isSpace -- slated to be removed later.
        (WebCore::FrameMac::shouldClose): Remove QChar cast, no longer needed.

        * bridge/mac/WebCoreFrameBridge.mm:
        (-[WebCoreFrameBridge selectedString]): Remove QChar cast, no longer needed.
        (-[WebCoreFrameBridge stringForRange:]): Ditto.

        * css/CSSGrammar.y: Update for field name change from string to characters.
        Use UChar instead of unsigned short.

        * css/css_valueimpl.cpp:
        (WebCore::propertyID): Use UChar instead of unsigned short and get rid of call to
        unicode() function, no longer needed.
        (WebCore::quoteStringIfNeeded): Use strings when building up a resulting string,
        instead of depending on the feature where you can append characters to a string.

        * css/csshelper.cpp: (WebCore::parseURL): Remove calls to unicode() function and
        rewrite to obviate the need to call lower() just to check for a few constant
        character values. Also remove a now-unneeded type cast.

        * css/cssparser.h: Changed ParseString field to use UChar and to be named characters
        instead of string. Changed many other fields to be UChar instead of unsigned short.
        (WebCore::domString): Update for that.
        (WebCore::atomicString): Ditto.
        * css/cssparser.cpp:
        (WebCore::ParseString::lower): Use u_tolower instead of QChar::lower(). Also change
        name to characters from string.
        (WebCore::CSSParser::setupParser): Use UChar instead of unsigned short.
        (WebCore::CSSParser::lex): Ditto. Also update for characters name change.
        (WebCore::CSSParser::text): Use UChar instead of unsigned short. Also tweak some
        of the code a little bit to handle a couple of overflow cases better and reduce
        type casting.
        (WebCore::deprecatedString): Moved here so we don't have to include DeprecatedString.h
        in the header file.

        * css/cssstyleselector.cpp: (WebCore::checkPseudoState): Added a type cast since this
        code now bridges the world between modern code and QChar/DeprecatedString.

        * dom/CharacterData.cpp: (WebCore::CharacterData::CharacterData): Changed QChar to UChar.

        * dom/Document.h:
        * dom/Document.cpp:
        (WebCore::Document::isValidName): Updated for name change from unicode to characters.
        (WebCore::Document::parseQualifiedName): Ditto.
        (WebCore::Document::backslashAsCurrencySymbol): Changed return type to UChar.

        * dom/NamedMappedAttrMap.cpp:
        (WebCore::isClassWhitespace): Changed parameter to UChar from QChar.
        (WebCore::NamedMappedAttrMap::parseClassAttribute): Changed from UChar to QChar and
        from unicode to characters.

        * dom/Position.cpp:
        (WebCore::Position::leadingWhitespacePosition): Changed from QChar to UChar.
        (WebCore::Position::trailingWhitespacePosition): Ditto.

        * dom/StyledElement.cpp:
        (WebCore::isClassWhitespace): Changed from QChar to UChar.
        (WebCore::StyledElement::addCSSLength): Changed from QChar to UChar, and remove one
        case where latin1() was used and was not helpful.
        (WebCore::StyledElement::addCSSColor): Removed unicode() function call, no longer needed.

        * dom/dom2_eventsimpl.cpp: (WebCore::KeyboardEvent::charCode):
        * html/HTMLInputElement.cpp: (WebCore::HTMLInputElement::constrainValue):
        Removed unicode() function call, no longer needed.

        * dom/xml_tokenizer.h: Removed default parameter for xmlDocPtrForString so we don't have
        to include the DeprecatedString.h header in this file (and since no one uses it).

        * editing/HTMLInterchange.cpp: (convertHTMLTextToInterchangeFormat): Added a couple calls
        to the unicode() function to bridge the gap from QChar/DeprecatedString back to modern
        code.

        * editing/InsertTextCommand.cpp: Removed unused function.

        * editing/TextIterator.h: Changed from QChar to UChar.
        * editing/TextIterator.cpp:
        (WebCore::TextIterator::TextIterator): Initialize m_lastCharacter since it's now a UChar
        (which is just a typedef) rather than a QChar (which was a class with a default value of 0).
        (WebCore::TextIterator::handleTextNode): Updated to use characters() instead of unicode().
        (WebCore::TextIterator::handleTextBox): Removed unicode() call since it's now a UChar instead
        of a QChar.
        (WebCore::TextIterator::emitCharacter): More of the same.
        (WebCore::SimplifiedBackwardsTextIterator::handleTextNode): Ditto.
        (WebCore::SimplifiedBackwardsTextIterator::emitCharacter): Ditto.
        (WebCore::CharacterIterator::string): Ditto.
        (WebCore::WordAwareIterator::advance): Ditto.
        (WebCore::WordAwareIterator::length): Ditto.
        (WebCore::WordAwareIterator::characters): Ditto.
        (WebCore::CircularSearchBuffer::CircularSearchBuffer): Changed to use UChar
        instead of QChar, but also to use foldCase() instead of lower(), because
        we want case folding here, not lowercasing.
        (WebCore::CircularSearchBuffer::append): Ditto, with u_foldCase.
        (WebCore::CircularSearchBuffer::isMatch): Ditto.
        (WebCore::plainText): Added type cast since this bridges the gap from the modern stuff
        to QChar/DeprecatedString.

        * editing/VisiblePosition.h: Changed from QChar to UChar.
        * editing/VisiblePosition.cpp: (WebCore::VisiblePosition::characterAfter): Ditto.

        * editing/markup.cpp: (WebCore::escapeTextForMarkup): Changed code that used latin1()
        for no good reason to use unicode() instead.

        * html/HTMLTokenizer.h: Changed from QChar to UChar.
        * html/HTMLTokenizer.cpp: Changed from QChar to UChar, including removing the
        KHTML_ALLOC_QCHAR_VEC and KHTML_DELETE_QCHAR_VEC macros, which weren't being
        used consistently anyway.
        (WebCore::fixUpChar): More of the same.
        (WebCore::tagMatch): Ditto.
        (WebCore::HTMLTokenizer::reset): Ditto.
        (WebCore::HTMLTokenizer::begin): Ditto. Also corrected anomaly where buffer
        size was not the same as the size value -- this was only true in the initial
        allocation, so I believe there was no value in it.
        (WebCore::HTMLTokenizer::parseSpecial): Ditto. Also removed a use of latin1()
        that was unnnecessary extra work.
        (WebCore::HTMLTokenizer::scriptHandler): More of the same.
        (WebCore::HTMLTokenizer::parseComment): Ditto.
        (WebCore::HTMLTokenizer::parseServer): Ditto.
        (WebCore::HTMLTokenizer::parseProcessingInstruction): Ditto. Another unnecessary
        use of latin1() removed.
        (WebCore::HTMLTokenizer::parseText): Ditto.
        (WebCore::HTMLTokenizer::parseEntity): Ditto. Changed hex-parsing code to handle
        uppercase hex a more-efficient way than calling QChar::lower() on each character.
        Also changed surrogate code logic to fix a couple things -- reject character codes
        > 0x10FFFF as it should and use U16_LEAD and U16_TRAIL instead of writing our
        own versions of these.
        (WebCore::HTMLTokenizer::parseTag): Ditto.
        (WebCore::HTMLTokenizer::write): Ditto.
        (WebCore::HTMLTokenizer::end): Ditto.
        (WebCore::HTMLTokenizer::finish): Ditto.
        (WebCore::HTMLTokenizer::enlargeBuffer): Ditto.
        (WebCore::HTMLTokenizer::enlargeScriptBuffer): Ditto.
        (WebCore::HTMLTokenizer::notifyFinished):
        (WebCore::decodeNamedEntity): Ditto.

        * html/html_inlineimpl.cpp: (WebCore::parseFontSizeNumber): Changed from QChar
        to UChar, including using u_isdigit and u_charDigitValue instead of QChar::isNumber
        and QChar::digitValue. Also removed unneeded range checking that's already done
        by WebCore::String.

        * kwq/KWQLoader.mm: (KWQIsResponseURLEqualToURL): Rewrote to use Vector and UChar,
        removing all the type casts and making the whole function much shorter.

        * kwq/WebCoreAXObject.mm:
        (AXAttributedStringAppendText): Use UChar instead of QChar.
        (-[WebCoreAXObject doAXAttributedStringForTextMarkerRange:]): More of the same.

        * loader/Cache.h: Remove unnecessary default parameters, preventing the need to
        include the DeprecatedString.h header in this header. Cleaned up the header
        structure a bit, removing some obsolete and redundant comments and fixing typos.
        * loader/Cache.cpp: Removed unused preload functions.

        * page/Frame.h:
        * page/Frame.cpp:
        (WebCore::UserStyleSheetLoader::UserStyleSheetLoader): Added explicit arguments.
        This was the only caller anywhere that took advantage of the default parameter
        values in one of the Cache class request functions.
        (WebCore::Frame::backslashAsCurrencySymbol): Changed QChar to UChar.

        * platform/AtomicString.h: Changed QChar to UChar. Removed constructor that makes
        an AtomicString from a single character. Renamed unicode() function to characters().
        Renamed KHTML_ATOMICSTRING_HIDE_GLOBALS to ATOMICSTRING_HIDE_GLOBALS.
        * platform/AtomicString.cpp:
        (WebCore::CStringTranslator::equal): Changed QChar to UChar.
        (WebCore::operator==): Changed unicode() to characters().
        (WebCore::UCharBufferTranslator::hash): More of the same.
        (WebCore::UCharBufferTranslator::equal): Ditto.
        (WebCore::UCharBufferTranslator::translate): Ditto.
        (WebCore::AtomicString::add): Ditto.
        (WebCore::AtomicString::operator Identifier): Ditto.
        (WebCore::AtomicString::operator UString): Ditto.
        (WebCore::AtomicString::AtomicString): Moved here so we don't need DeprecatedString.h
        in the header.
        (WebCore::AtomicString::deprecatedString): Ditto.

        * platform/DeprecatedString.h: Removed QChar::Direction enum and all the DirXXX values,
        isDigit, isLetter, isNumber, isLetterOrNumber, isPunct, digitValue, and direction functions.
        (QChar::isSpace): Changed to use u_charDirection instead of QChar::direction.

        * platform/Font.h: (WebCore::Font::width): Changed QChar to UChar.
        * platform/Font.cpp: (WebCore::Font::width): Ditto.

        * platform/GraphicsContext.h:
        * platform/GraphicsContext.cpp:
        (WebCore::GraphicsContext::drawText): Changed QChar to UChar. Removed horizontalAlignment
        parameter from simplified string drawing entry point, since it's not used.
        (WebCore::GraphicsContext::drawHighlightForText): Changed QChar to UChar.

        * platform/PlatformString.h: Changed QChar to UChar. Removed constructor that makes
        a String from a single character. Renamed unicode() function to characters(). Added
        an append function and changed += operator to just call that. Added a foldCase() function.
        Removed the concatenation operators that add individual strings before or after.
        * platform/String.cpp:
        (WebCore::String::String): Changed QChar to UChar.
        (WebCore::String::append): Renamed from operator+= and removed the return value.
        (WebCore::String::operator[]): Changed QChar to UChar.
        (WebCore::String::foldCase): Added.
        (WebCore::String::percentage): More of the same.
        (WebCore::String::characters): Renamed from unicode().
        (WebCore::String::deprecatedString): More of the same.
        (WebCore::String::sprintf): Fixed mistakes in the comments.
        (WebCore::String::isEmpty): Tweaked a bit.
        (WebCore::operator==): More of the same.
        (WebCore::String::operator Identifier): Ditto.
        (WebCore::String::operator UString): Ditto.

        * platform/SegmentedString.h: Changed from QChar to UChar. Had to initialize
        data members that are now UChar.
        * platform/SegmentedString.cpp:
        (WebCore::SegmentedString::length): Updated for change from QChar to UChar.
        (WebCore::SegmentedString::append): Ditto.
        (WebCore::SegmentedString::prepend): Ditto.
        (WebCore::SegmentedString::toString): Ditto.

        * platform/StringHash.h: Updated to use UChar instead of QChar and for name changes.
        Also changed to use case folding intead of lowercasing for case insensitive hashing.

        * platform/StringImpl.h:
        * platform/StringImpl.cpp:
        (WebCore::newUCharVector): Changed to UChar from QChar.
        (WebCore::deleteUCharVector): Ditto.
        (WebCore::StringImpl::StringImpl): Ditto.
        (WebCore::StringImpl::init): Ditto. Also renamed from initWithChar and initWithQChar.
        (WebCore::StringImpl::~StringImpl): Ditto.
        (WebCore::StringImpl::append): Ditto.
        (WebCore::StringImpl::insert): Ditto.
        (WebCore::StringImpl::truncate): Ditto.
        (WebCore::StringImpl::remove): Ditto.
        (WebCore::StringImpl::split): Ditto.
        (WebCore::StringImpl::containsOnlyWhitespace): Ditto. Also added comment because this
        function seems a little broken.
        (WebCore::parseLength): More of the same.
        (WebCore::StringImpl::toCoordsArray): Ditto.
        (WebCore::StringImpl::toLengthArray): Ditto.
        (WebCore::StringImpl::isLower): Ditto.
        (WebCore::StringImpl::lower): Rewrote to use u_strToLower.
        (WebCore::StringImpl::upper): Rewrote to use u_strToUpper.
        (WebCore::StringImpl::foldCase): Added. Uses u_strFoldCase.
        (WebCore::getWordBreakIterator): Changed to use U_FAILURE instead of accepting only
        U_ZERO_ERROR as a success code.
        (WebCore::StringImpl::capitalize): More QChar to UChar changes.
        (WebCore::StringImpl::toInt): Ditto.
        (WebCore::equal): Changed from QChar to UChar and was careful to preserve the old
        semantics where "high ASCII" is treated as U+0080-U+00FF even though I don't know
        if this feature is important.
        (WebCore::equalIgnoringCase): Ditto, but used case folding instead of lowercasing
        by using the u_foldCase and u_memcasecmp functions. Also renamed from
        equalCaseInsensitive for more-consistent naming.
        (WebCore::StringImpl::find): Ditto. Use case folding for the case insensitive branch.
        (WebCore::StringImpl::replace): More of the same.
        (WebCore::StringImpl::computeHash): Ditto.
        (WebCore::StringImpl::ascii): Ditto.

        * platform/TextBoundaries.h: Changed from QChar to UChar.
        * platform/mac/TextBoundaries.mm:
        (WebCore::findWordBoundary): Made the change to UChar and removed some type casts.
        (WebCore::findNextWordFromIndex): Ditto.
        (WebCore::findSentenceBoundary): Ditto.
        (WebCore::findNextSentenceFromIndex): Ditto.

        * platform/TextEncoding.h:
        * platform/TextEncoding.cpp:
        (WebCore::TextEncoding::backslashAsCurrencySymbol): Changed from QChar to UChar.
        (WebCore::TextEncoding::fromUnicode): More of the same.
        * platform/mac/TextEncodingMac.cpp: (WebCore::TextEncoding::fromUnicode): More
        of the same.

        * platform/mac/FontFamilyMac.mm: (WebCore::FontFamily::getNSFamily): Removed a
        now-unneeded type cast.

        * platform/mac/FontMac.mm:
        (WebCore::Font::selectionRectForText):
        (WebCore::Font::drawText):
        (WebCore::Font::drawHighlightForText):
        (WebCore::Font::floatWidth):
        (WebCore::Font::checkSelectionPoint):
        Changed QChar to UChar and removed some now-unneeded type casts.

        * editing/RebalanceWhitespaceCommand.cpp: (WebCore::isWhitespace):
        * editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::doApply):
        * editing/visible_units.cpp:
        (WebCore::previousBoundary):
        (WebCore::nextBoundary):
        (WebCore::startWordBoundary):
        (WebCore::endWordBoundary):
        (WebCore::previousWordPositionBoundary):
        (WebCore::nextWordPositionBoundary):
        (WebCore::startSentenceBoundary):
        (WebCore::endSentenceBoundary):
        (WebCore::previousSentencePositionBoundary):
        (WebCore::nextSentencePositionBoundary):
        (WebCore::startOfParagraph):
        (WebCore::endOfParagraph):
        * html/HTMLParser.cpp: (WebCore::HTMLParser::handleError):
        * rendering/InlineTextBox.cpp:
        (WebCore::InlineTextBox::selectionRect):
        (WebCore::InlineTextBox::paint):
        (WebCore::InlineTextBox::paintSelection):
        (WebCore::InlineTextBox::paintMarkedTextBackground):
        (WebCore::InlineTextBox::paintTextMatchMarker):
        (WebCore::InlineTextBox::offsetForPosition):
        (WebCore::InlineTextBox::positionForOffset):
        * rendering/RenderBlock.cpp:
        (WebCore::stripTrailingSpace):
        (WebCore::RenderBlock::updateFirstLetter):
        * rendering/RenderFlexibleBox.cpp:
        (WebCore::RenderFlexibleBox::layoutVerticalBox):
        * rendering/RenderObject.h:
        * rendering/RenderObject.cpp:
        (WebCore::RenderObject::backslashAsCurrencySymbol):
        * rendering/RenderTreeAsText.cpp: (quoteAndEscapeNonPrintables):
        * rendering/break_lines.cpp: (WebCore::nextBreakablePosition):
        * rendering/break_lines.h: (WebCore::isBreakable):
        * rendering/render_style.h: (WebCore::RenderStyle::isCollapsibleWhiteSpace):
        * xml/XSLStyleSheet.cpp: (WebCore::XSLStyleSheet::parseString):
        * xml/xmlhttprequest.cpp:
        (WebCore::getMIMEType):
        (WebCore::getCharset):
        Changed QChar to UChar.

        * rendering/RenderImage.cpp:
        (WebCore::RenderImage::imageChanged): Changed QChar to UChar.
        (WebCore::RenderImage::paint): Changed callers of drawText to no-longer pass 0
        for the horizontal alignment, since I removed that parameters.

        * rendering/RenderText.h: Changed QChar to UChar.
        * rendering/RenderText.cpp:
        (WebCore::characterBreakIterator): Update for name change.
        (WebCore::RenderText::RenderText): Ditto.
        (WebCore::RenderText::allAscii): Remove uneeded unicode() and allow the value
        U+007F to count as ASCII.
        (WebCore::RenderText::cacheWidths): Changed QChar to UChar.
        (WebCore::RenderText::widthFromCache): Changed code that deals with direction to
        use the ICU direction calls.
        (WebCore::RenderText::trimmedMinMaxWidth): Changed QChar to UChar.
        (WebCore::RenderText::calcMinMaxWidth): Ditto.
        (WebCore::RenderText::containsOnlyWhitespace): Ditto.
        (WebCore::RenderText::setText): Ditto.
        (WebCore::RenderText::width): Ditto.

        * rendering/RenderTextField.cpp:
        (WebCore::RenderTextField::updateFromElement): Removed unneeded QChar cast.
        (WebCore::RenderTextField::calcMinMaxWidth): Changed from QChar to UChar.

        * rendering/bidi.h:
        * rendering/bidi.cpp:
        (WebCore::BidiIterator::BidiIterator):
        (WebCore::BidiState::BidiState):
        (WebCore::BidiContext::BidiContext):
        (WebCore::bidiNext):
        (WebCore::bidiFirst):
        (WebCore::BidiIterator::current):
        (WebCore::BidiIterator::direction):
        (WebCore::addRun):
        (WebCore::checkMidpoints):
        (WebCore::appendRun):
        (WebCore::embed):
        (WebCore::RenderBlock::tabWidth):
        (WebCore::RenderBlock::computeHorizontalPositionsForLine):
        (WebCore::RenderBlock::bidiReorderLine):
        (WebCore::RenderBlock::layoutInlineChildren):
        (WebCore::skipNonBreakingSpace):
        (WebCore::RenderBlock::skipWhitespace):
        (WebCore::RenderBlock::findNextLineBreak):
        (WebCore::RenderBlock::checkLinesForTextOverflow):
        Changed from QChar to UChar and all direction from QChar constants to the
        ones from ICU.

        * rendering/render_form.cpp:
        (WebCore::RenderLineEdit::updateFromElement):
        (WebCore::RenderSelect::updateFromElement):
        (WebCore::RenderTextArea::updateFromElement):
        (WebCore::RenderTextArea::text):
        (WebCore::RenderTextArea::textWithHardLineBreaks):
        Got rid of now-unneeded QChar type casts.

        * rendering/render_line.cpp:
        (WebCore::InlineFlowBox::placeBoxesHorizontally): Updated for change from QChar
        to UChar.
        (WebCore::EllipsisBox::paint): Updated for unicode() -> characters() name change.

        * rendering/render_list.cpp:
        (WebCore::toRoman): Updated from QChar to UChar.
        (WebCore::toLetterString): Ditto.
        (WebCore::toHebrew): More of the same, also cleaned up the logic a bit.
        (WebCore::RenderListMarker::paint): Removed the alignment parameters from the
        various functions. Also removed all reliance on the width-measuring functions
        that take a string.
        (WebCore::RenderListMarker::calcMinMaxWidth): More of the same.
        (WebCore::RenderListMarker::getRelativeMarkerRect): Ditto.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@14273 268f45cc-cd09-0410-ab3c-d52691b4dbfc

106 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/css/case-transform-expected.txt [new file with mode: 0644]
LayoutTests/fast/css/case-transform.html [new file with mode: 0644]
WebCore/ChangeLog
WebCore/bindings/js/JSXMLSerializer.cpp
WebCore/bindings/js/kjs_css.cpp
WebCore/bindings/js/kjs_navigator.cpp
WebCore/bindings/js/kjs_proxy.cpp
WebCore/bindings/js/kjs_window.cpp
WebCore/bindings/objc/DOMInternal.mm
WebCore/bridge/mac/FrameMac.mm
WebCore/bridge/mac/WebCoreFrameBridge.mm
WebCore/css/CSSGrammar.y
WebCore/css/css_valueimpl.cpp
WebCore/css/css_valueimpl.h
WebCore/css/csshelper.cpp
WebCore/css/cssparser.cpp
WebCore/css/cssparser.h
WebCore/css/cssstyleselector.cpp
WebCore/dom/CharacterData.cpp
WebCore/dom/Document.cpp
WebCore/dom/Document.h
WebCore/dom/NamedMappedAttrMap.cpp
WebCore/dom/Position.cpp
WebCore/dom/StyledElement.cpp
WebCore/dom/dom2_eventsimpl.cpp
WebCore/dom/xml_tokenizer.h
WebCore/editing/HTMLInterchange.cpp
WebCore/editing/InsertTextCommand.cpp
WebCore/editing/RebalanceWhitespaceCommand.cpp
WebCore/editing/ReplaceSelectionCommand.cpp
WebCore/editing/TextIterator.cpp
WebCore/editing/TextIterator.h
WebCore/editing/VisiblePosition.cpp
WebCore/editing/VisiblePosition.h
WebCore/editing/markup.cpp
WebCore/editing/visible_units.cpp
WebCore/html/HTMLInputElement.cpp
WebCore/html/HTMLParser.cpp
WebCore/html/HTMLTokenizer.cpp
WebCore/html/HTMLTokenizer.h
WebCore/html/html_inlineimpl.cpp
WebCore/kwq/KWQLoader.mm
WebCore/kwq/KWQTextStream.cpp
WebCore/kwq/WebCoreAXObject.mm
WebCore/loader/Cache.cpp
WebCore/loader/Cache.h
WebCore/loader/CachedObject.h
WebCore/page/Frame.cpp
WebCore/page/Frame.h
WebCore/platform/AtomicString.cpp
WebCore/platform/AtomicString.h
WebCore/platform/Color.cpp
WebCore/platform/DeprecatedString.h
WebCore/platform/Font.cpp
WebCore/platform/Font.h
WebCore/platform/GraphicsContext.cpp
WebCore/platform/GraphicsContext.h
WebCore/platform/PlatformString.h
WebCore/platform/SegmentedString.cpp
WebCore/platform/SegmentedString.h
WebCore/platform/StreamingTextDecoder.cpp
WebCore/platform/StreamingTextDecoder.h
WebCore/platform/String.cpp
WebCore/platform/StringHash.h
WebCore/platform/StringImpl.cpp
WebCore/platform/StringImpl.h
WebCore/platform/TextBoundaries.h
WebCore/platform/TextEncoding.cpp
WebCore/platform/TextEncoding.h
WebCore/platform/mac/FontFamilyMac.mm
WebCore/platform/mac/FontMac.mm
WebCore/platform/mac/TextBoundaries.mm
WebCore/platform/mac/TextEncodingMac.cpp
WebCore/rendering/InlineTextBox.cpp
WebCore/rendering/RenderBlock.cpp
WebCore/rendering/RenderFlexibleBox.cpp
WebCore/rendering/RenderImage.cpp
WebCore/rendering/RenderObject.cpp
WebCore/rendering/RenderObject.h
WebCore/rendering/RenderText.cpp
WebCore/rendering/RenderText.h
WebCore/rendering/RenderTextField.cpp
WebCore/rendering/RenderTreeAsText.cpp
WebCore/rendering/bidi.cpp
WebCore/rendering/bidi.h
WebCore/rendering/break_lines.cpp
WebCore/rendering/break_lines.h
WebCore/rendering/render_form.cpp
WebCore/rendering/render_line.cpp
WebCore/rendering/render_list.cpp
WebCore/rendering/render_style.cpp
WebCore/rendering/render_style.h
WebCore/xml/XSLStyleSheet.cpp
WebCore/xml/xmlhttprequest.cpp
WebCore/xpath/impl/XPathExpressionNode.cpp
WebCore/xpath/impl/XPathExpressionNode.h
WebCore/xpath/impl/XPathFunctions.cpp
WebCore/xpath/impl/XPathGrammar.y
WebCore/xpath/impl/XPathParser.cpp
WebCore/xpath/impl/XPathParser.h
WebCore/xpath/impl/XPathPath.cpp
WebCore/xpath/impl/XPathPredicate.cpp
WebCore/xpath/impl/XPathValue.cpp
WebCore/xpath/impl/XPathValue.h
WebCore/xpath/impl/XPathVariableReference.cpp

index 9032f71..f122261 100644 (file)
@@ -1,3 +1,11 @@
+2006-05-09  Darin Adler  <darin@apple.com>
+
+        - test for http://bugzilla.opendarwin.org/show_bug.cgi?id=6310
+          text-transform: uppercase/lowercase don't handle cases one character becomes two
+
+        * fast/css/case-transform.html: Added.
+        * fast/css/case-transform-expected.txt: Added.
+
 2006-05-09  Levi Weintraub  <lweintraub@apple.com>
 
         Reviewed by justin.
diff --git a/LayoutTests/fast/css/case-transform-expected.txt b/LayoutTests/fast/css/case-transform-expected.txt
new file mode 100644 (file)
index 0000000..6c7f9a7
--- /dev/null
@@ -0,0 +1,17 @@
+lower(A𐐀) = a𐐨 (should be a𐐨)
+
+upper(a𐐨) = A𐐀 (should be A𐐀)
+
+lower(ΚΟΣΜΟΣ) = κοσμος (should be κοσμος)
+
+upper(ß) = SS (should be SS)
+
+upper(ʼn) = ʼN (should be ʼN)
+
+upper(ǰ) = J̌ (should be J̌)
+
+upper(ffi) = FFI (should be FFI)
+
+lower(IJ) = ij (should be ij)
+
+
diff --git a/LayoutTests/fast/css/case-transform.html b/LayoutTests/fast/css/case-transform.html
new file mode 100644 (file)
index 0000000..fc58652
--- /dev/null
@@ -0,0 +1,16 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<script>if (window.layoutTestController) layoutTestController.dumpAsText();</script>
+</head>
+<body>
+<p>lower(A𐐀) = <span style="text-transform:lowercase">A𐐀</span> (should be a𐐨)</p>
+<p>upper(a𐐨) = <span style="text-transform:uppercase">a𐐨</span> (should be A𐐀)</p>
+<p>lower(ΚΟΣΜΟΣ) = <span style="text-transform:lowercase">ΚΟΣΜΟΣ</span> (should be κοσμος)</p>
+<p>upper(ß) = <span style="text-transform:uppercase">ß</span> (should be SS)</p>
+<p>upper(ʼn) = <span style="text-transform:uppercase">ʼn</span> (should be ʼN)</p>
+<p>upper(ǰ) = <span style="text-transform:uppercase">ǰ</span> (should be J̌)</p>
+<p>upper(ffi) = <span style="text-transform:uppercase">ffi</span> (should be FFI)</p>
+<p>lower(IJ) = <span style="text-transform:lowercase">IJ</span> (should be ij)</p>
+</body>
+</html>
index 5764197..f87fc70 100644 (file)
@@ -1,3 +1,439 @@
+2006-05-09  Darin Adler  <darin@apple.com>
+
+        Rubber stamped by Hyatt.
+
+        - http://bugzilla.opendarwin.org/show_bug.cgi?id=8782
+          use ICU and UChar more, QChar less
+
+        - fix http://bugzilla.opendarwin.org/show_bug.cgi?id=6310
+          text-transform: uppercase/lowercase don't handle cases one character becomes two
+
+        Test: fast/css/case-transform.html
+
+        By using ICU more, this fixes some bugs in a few places.
+
+        * bindings/js/JSXMLSerializer.cpp:
+        * css/css_valueimpl.h:
+        * kwq/KWQTextStream.cpp:
+        * loader/CachedObject.h:
+        * platform/Color.cpp:
+        Add includes of DeprecatedString.h as needed, now that StringImpl.h no longer
+        includes it.
+
+        * bindings/js/kjs_css.cpp: (KJS::cssPropertyName):
+        Eliminate use of QChar::latin1() in a case where it's not helpful.
+
+        * bindings/js/kjs_proxy.cpp: (WebCore::KJSProxy::evaluate):
+        Use characters() function instead of the old unicode() function.
+
+        * bindings/js/kjs_window.cpp: (KJS::isSeparator):
+        Use UChar instead of QChar.
+
+        * bindings/objc/DOMInternal.mm:
+        (StringImpl::operator NSString*): Remove typecast that's no longer needed.
+        (String::String): Ditto. Also use Vector for local buffer to make code read simpler.
+
+        * bridge/mac/FrameMac.mm:
+        (WebCore::selectorForKeyEvent): Remove call to unicode() function, no longer needed.
+        (WebCore::FrameMac::setTitle): Remove QChar cast, no longer needed.
+        (WebCore::FrameMac::setStatusBarText): Ditto.
+        (WebCore::FrameMac::advanceToNextMisspelling): Use UChar instead of QChar.
+        (WebCore::FrameMac::runJavaScriptAlert): Remove QChar cast, no longer needed.
+        (WebCore::FrameMac::runJavaScriptConfirm): Ditto.
+        (WebCore::FrameMac::runJavaScriptPrompt): Ditto.
+        (WebCore::FrameMac::attributedString): Replaces calls of QChar::direction() with
+        calls to u_charDirection and use ICU constants instead of QChar ones.
+        (WebCore::FrameMac::markMisspellings): Remove QChar cast, no longer needed. Added a
+        QChar cast so we can call isSpace -- slated to be removed later.
+        (WebCore::FrameMac::shouldClose): Remove QChar cast, no longer needed.
+
+        * bridge/mac/WebCoreFrameBridge.mm:
+        (-[WebCoreFrameBridge selectedString]): Remove QChar cast, no longer needed.
+        (-[WebCoreFrameBridge stringForRange:]): Ditto.
+
+        * css/CSSGrammar.y: Update for field name change from string to characters.
+        Use UChar instead of unsigned short. 
+
+        * css/css_valueimpl.cpp:
+        (WebCore::propertyID): Use UChar instead of unsigned short and get rid of call to
+        unicode() function, no longer needed.
+        (WebCore::quoteStringIfNeeded): Use strings when building up a resulting string,
+        instead of depending on the feature where you can append characters to a string.
+
+        * css/csshelper.cpp: (WebCore::parseURL): Remove calls to unicode() function and
+        rewrite to obviate the need to call lower() just to check for a few constant
+        character values. Also remove a now-unneeded type cast.
+
+        * css/cssparser.h: Changed ParseString field to use UChar and to be named characters
+        instead of string. Changed many other fields to be UChar instead of unsigned short.
+        (WebCore::domString): Update for that.
+        (WebCore::atomicString): Ditto.
+        * css/cssparser.cpp:
+        (WebCore::ParseString::lower): Use u_tolower instead of QChar::lower(). Also change
+        name to characters from string.
+        (WebCore::CSSParser::setupParser): Use UChar instead of unsigned short.
+        (WebCore::CSSParser::lex): Ditto. Also update for characters name change.
+        (WebCore::CSSParser::text): Use UChar instead of unsigned short. Also tweak some
+        of the code a little bit to handle a couple of overflow cases better and reduce
+        type casting.
+        (WebCore::deprecatedString): Moved here so we don't have to include DeprecatedString.h
+        in the header file.
+
+        * css/cssstyleselector.cpp: (WebCore::checkPseudoState): Added a type cast since this
+        code now bridges the world between modern code and QChar/DeprecatedString.
+
+        * dom/CharacterData.cpp: (WebCore::CharacterData::CharacterData): Changed QChar to UChar.
+
+        * dom/Document.h:
+        * dom/Document.cpp:
+        (WebCore::Document::isValidName): Updated for name change from unicode to characters.
+        (WebCore::Document::parseQualifiedName): Ditto.
+        (WebCore::Document::backslashAsCurrencySymbol): Changed return type to UChar.
+
+        * dom/NamedMappedAttrMap.cpp:
+        (WebCore::isClassWhitespace): Changed parameter to UChar from QChar.
+        (WebCore::NamedMappedAttrMap::parseClassAttribute): Changed from UChar to QChar and
+        from unicode to characters.
+
+        * dom/Position.cpp:
+        (WebCore::Position::leadingWhitespacePosition): Changed from QChar to UChar.
+        (WebCore::Position::trailingWhitespacePosition): Ditto.
+
+        * dom/StyledElement.cpp:
+        (WebCore::isClassWhitespace): Changed from QChar to UChar.
+        (WebCore::StyledElement::addCSSLength): Changed from QChar to UChar, and remove one
+        case where latin1() was used and was not helpful.
+        (WebCore::StyledElement::addCSSColor): Removed unicode() function call, no longer needed.
+
+        * dom/dom2_eventsimpl.cpp: (WebCore::KeyboardEvent::charCode):
+        * html/HTMLInputElement.cpp: (WebCore::HTMLInputElement::constrainValue):
+        Removed unicode() function call, no longer needed.
+
+        * dom/xml_tokenizer.h: Removed default parameter for xmlDocPtrForString so we don't have
+        to include the DeprecatedString.h header in this file (and since no one uses it).
+
+        * editing/HTMLInterchange.cpp: (convertHTMLTextToInterchangeFormat): Added a couple calls
+        to the unicode() function to bridge the gap from QChar/DeprecatedString back to modern
+        code.
+
+        * editing/InsertTextCommand.cpp: Removed unused function.
+
+        * editing/TextIterator.h: Changed from QChar to UChar.
+        * editing/TextIterator.cpp:
+        (WebCore::TextIterator::TextIterator): Initialize m_lastCharacter since it's now a UChar
+        (which is just a typedef) rather than a QChar (which was a class with a default value of 0).
+        (WebCore::TextIterator::handleTextNode): Updated to use characters() instead of unicode().
+        (WebCore::TextIterator::handleTextBox): Removed unicode() call since it's now a UChar instead
+        of a QChar.
+        (WebCore::TextIterator::emitCharacter): More of the same.
+        (WebCore::SimplifiedBackwardsTextIterator::handleTextNode): Ditto.
+        (WebCore::SimplifiedBackwardsTextIterator::emitCharacter): Ditto.
+        (WebCore::CharacterIterator::string): Ditto.
+        (WebCore::WordAwareIterator::advance): Ditto.
+        (WebCore::WordAwareIterator::length): Ditto.
+        (WebCore::WordAwareIterator::characters): Ditto.
+        (WebCore::CircularSearchBuffer::CircularSearchBuffer): Changed to use UChar
+        instead of QChar, but also to use foldCase() instead of lower(), because
+        we want case folding here, not lowercasing.
+        (WebCore::CircularSearchBuffer::append): Ditto, with u_foldCase.
+        (WebCore::CircularSearchBuffer::isMatch): Ditto.
+        (WebCore::plainText): Added type cast since this bridges the gap from the modern stuff
+        to QChar/DeprecatedString.
+
+        * editing/VisiblePosition.h: Changed from QChar to UChar.
+        * editing/VisiblePosition.cpp: (WebCore::VisiblePosition::characterAfter): Ditto.
+
+        * editing/markup.cpp: (WebCore::escapeTextForMarkup): Changed code that used latin1()
+        for no good reason to use unicode() instead.
+        * html/HTMLTokenizer.h: Changed from QChar to UChar.
+        * html/HTMLTokenizer.cpp: Changed from QChar to UChar, including removing the
+        KHTML_ALLOC_QCHAR_VEC and KHTML_DELETE_QCHAR_VEC macros, which weren't being
+        used consistently anyway.
+        (WebCore::fixUpChar): More of the same.
+        (WebCore::tagMatch): Ditto.
+        (WebCore::HTMLTokenizer::reset): Ditto.
+        (WebCore::HTMLTokenizer::begin): Ditto. Also corrected anomaly where buffer
+        size was not the same as the size value -- this was only true in the initial
+        allocation, so I believe there was no value in it.
+        (WebCore::HTMLTokenizer::parseSpecial): Ditto. Also removed a use of latin1()
+        that was unnnecessary extra work.
+        (WebCore::HTMLTokenizer::scriptHandler): More of the same.
+        (WebCore::HTMLTokenizer::parseComment): Ditto.
+        (WebCore::HTMLTokenizer::parseServer): Ditto.
+        (WebCore::HTMLTokenizer::parseProcessingInstruction): Ditto. Another unnecessary
+        use of latin1() removed.
+        (WebCore::HTMLTokenizer::parseText): Ditto.
+        (WebCore::HTMLTokenizer::parseEntity): Ditto. Changed hex-parsing code to handle
+        uppercase hex a more-efficient way than calling QChar::lower() on each character.
+        Also changed surrogate code logic to fix a couple things -- reject character codes
+        > 0x10FFFF as it should and use U16_LEAD and U16_TRAIL instead of writing our
+        own versions of these.
+        (WebCore::HTMLTokenizer::parseTag): Ditto.
+        (WebCore::HTMLTokenizer::write): Ditto.
+        (WebCore::HTMLTokenizer::end): Ditto.
+        (WebCore::HTMLTokenizer::finish): Ditto.
+        (WebCore::HTMLTokenizer::enlargeBuffer): Ditto.
+        (WebCore::HTMLTokenizer::enlargeScriptBuffer): Ditto.
+        (WebCore::HTMLTokenizer::notifyFinished):
+        (WebCore::decodeNamedEntity): Ditto.
+
+        * html/html_inlineimpl.cpp: (WebCore::parseFontSizeNumber): Changed from QChar
+        to UChar, including using u_isdigit and u_charDigitValue instead of QChar::isNumber
+        and QChar::digitValue. Also removed unneeded range checking that's already done
+        by WebCore::String.
+
+        * kwq/KWQLoader.mm: (KWQIsResponseURLEqualToURL): Rewrote to use Vector and UChar,
+        removing all the type casts and making the whole function much shorter.
+
+        * kwq/WebCoreAXObject.mm:
+        (AXAttributedStringAppendText): Use UChar instead of QChar.
+        (-[WebCoreAXObject doAXAttributedStringForTextMarkerRange:]): More of the same.
+
+        * loader/Cache.h: Remove unnecessary default parameters, preventing the need to
+        include the DeprecatedString.h header in this header. Cleaned up the header
+        structure a bit, removing some obsolete and redundant comments and fixing typos.
+        * loader/Cache.cpp: Removed unused preload functions.
+
+        * page/Frame.h:
+        * page/Frame.cpp:
+        (WebCore::UserStyleSheetLoader::UserStyleSheetLoader): Added explicit arguments.
+        This was the only caller anywhere that took advantage of the default parameter
+        values in one of the Cache class request functions.
+        (WebCore::Frame::backslashAsCurrencySymbol): Changed QChar to UChar.
+
+        * platform/AtomicString.h: Changed QChar to UChar. Removed constructor that makes
+        an AtomicString from a single character. Renamed unicode() function to characters().
+        Renamed KHTML_ATOMICSTRING_HIDE_GLOBALS to ATOMICSTRING_HIDE_GLOBALS.
+        * platform/AtomicString.cpp:
+        (WebCore::CStringTranslator::equal): Changed QChar to UChar.
+        (WebCore::operator==): Changed unicode() to characters().
+        (WebCore::UCharBufferTranslator::hash): More of the same.
+        (WebCore::UCharBufferTranslator::equal): Ditto.
+        (WebCore::UCharBufferTranslator::translate): Ditto.
+        (WebCore::AtomicString::add): Ditto.
+        (WebCore::AtomicString::operator Identifier): Ditto.
+        (WebCore::AtomicString::operator UString): Ditto.
+        (WebCore::AtomicString::AtomicString): Moved here so we don't need DeprecatedString.h
+        in the header.
+        (WebCore::AtomicString::deprecatedString): Ditto.
+
+        * platform/DeprecatedString.h: Removed QChar::Direction enum and all the DirXXX values,
+        isDigit, isLetter, isNumber, isLetterOrNumber, isPunct, digitValue, and direction functions.
+        (QChar::isSpace): Changed to use u_charDirection instead of QChar::direction.
+
+        * platform/Font.h: (WebCore::Font::width): Changed QChar to UChar.
+        * platform/Font.cpp: (WebCore::Font::width): Ditto.
+
+        * platform/GraphicsContext.h:
+        * platform/GraphicsContext.cpp:
+        (WebCore::GraphicsContext::drawText): Changed QChar to UChar. Removed horizontalAlignment
+        parameter from simplified string drawing entry point, since it's not used.
+        (WebCore::GraphicsContext::drawHighlightForText): Changed QChar to UChar.
+
+        * platform/PlatformString.h: Changed QChar to UChar. Removed constructor that makes
+        a String from a single character. Renamed unicode() function to characters(). Added
+        an append function and changed += operator to just call that. Added a foldCase() function.
+        Removed the concatenation operators that add individual strings before or after.
+        * platform/String.cpp:
+        (WebCore::String::String): Changed QChar to UChar.
+        (WebCore::String::append): Renamed from operator+= and removed the return value.
+        (WebCore::String::operator[]): Changed QChar to UChar.
+        (WebCore::String::foldCase): Added.
+        (WebCore::String::percentage): More of the same.
+        (WebCore::String::characters): Renamed from unicode().
+        (WebCore::String::deprecatedString): More of the same.
+        (WebCore::String::sprintf): Fixed mistakes in the comments.
+        (WebCore::String::isEmpty): Tweaked a bit.
+        (WebCore::operator==): More of the same.
+        (WebCore::String::operator Identifier): Ditto.
+        (WebCore::String::operator UString): Ditto.
+
+        * platform/SegmentedString.h: Changed from QChar to UChar. Had to initialize
+        data members that are now UChar.
+        * platform/SegmentedString.cpp:
+        (WebCore::SegmentedString::length): Updated for change from QChar to UChar.
+        (WebCore::SegmentedString::append): Ditto.
+        (WebCore::SegmentedString::prepend): Ditto.
+        (WebCore::SegmentedString::toString): Ditto.
+
+        * platform/StringHash.h: Updated to use UChar instead of QChar and for name changes.
+        Also changed to use case folding intead of lowercasing for case insensitive hashing.
+
+        * platform/StringImpl.h:
+        * platform/StringImpl.cpp:
+        (WebCore::newUCharVector): Changed to UChar from QChar.
+        (WebCore::deleteUCharVector): Ditto.
+        (WebCore::StringImpl::StringImpl): Ditto.
+        (WebCore::StringImpl::init): Ditto. Also renamed from initWithChar and initWithQChar.
+        (WebCore::StringImpl::~StringImpl): Ditto.
+        (WebCore::StringImpl::append): Ditto.
+        (WebCore::StringImpl::insert): Ditto.
+        (WebCore::StringImpl::truncate): Ditto.
+        (WebCore::StringImpl::remove): Ditto.
+        (WebCore::StringImpl::split): Ditto.
+        (WebCore::StringImpl::containsOnlyWhitespace): Ditto. Also added comment because this
+        function seems a little broken.
+        (WebCore::parseLength): More of the same.
+        (WebCore::StringImpl::toCoordsArray): Ditto.
+        (WebCore::StringImpl::toLengthArray): Ditto.
+        (WebCore::StringImpl::isLower): Ditto.
+        (WebCore::StringImpl::lower): Rewrote to use u_strToLower.
+        (WebCore::StringImpl::upper): Rewrote to use u_strToUpper.
+        (WebCore::StringImpl::foldCase): Added. Uses u_strFoldCase.
+        (WebCore::getWordBreakIterator): Changed to use U_FAILURE instead of accepting only
+        U_ZERO_ERROR as a success code.
+        (WebCore::StringImpl::capitalize): More QChar to UChar changes.
+        (WebCore::StringImpl::toInt): Ditto.
+        (WebCore::equal): Changed from QChar to UChar and was careful to preserve the old
+        semantics where "high ASCII" is treated as U+0080-U+00FF even though I don't know
+        if this feature is important.
+        (WebCore::equalIgnoringCase): Ditto, but used case folding instead of lowercasing
+        by using the u_foldCase and u_memcasecmp functions. Also renamed from
+        equalCaseInsensitive for more-consistent naming.
+        (WebCore::StringImpl::find): Ditto. Use case folding for the case insensitive branch.
+        (WebCore::StringImpl::replace): More of the same.
+        (WebCore::StringImpl::computeHash): Ditto.
+        (WebCore::StringImpl::ascii): Ditto.
+
+        * platform/TextBoundaries.h: Changed from QChar to UChar.
+        * platform/mac/TextBoundaries.mm:
+        (WebCore::findWordBoundary): Made the change to UChar and removed some type casts.
+        (WebCore::findNextWordFromIndex): Ditto.
+        (WebCore::findSentenceBoundary): Ditto.
+        (WebCore::findNextSentenceFromIndex): Ditto.
+
+        * platform/TextEncoding.h:
+        * platform/TextEncoding.cpp:
+        (WebCore::TextEncoding::backslashAsCurrencySymbol): Changed from QChar to UChar.
+        (WebCore::TextEncoding::fromUnicode): More of the same.
+        * platform/mac/TextEncodingMac.cpp: (WebCore::TextEncoding::fromUnicode): More
+        of the same.
+
+        * platform/mac/FontFamilyMac.mm: (WebCore::FontFamily::getNSFamily): Removed a
+        now-unneeded type cast.
+
+        * platform/mac/FontMac.mm:
+        (WebCore::Font::selectionRectForText):
+        (WebCore::Font::drawText):
+        (WebCore::Font::drawHighlightForText):
+        (WebCore::Font::floatWidth):
+        (WebCore::Font::checkSelectionPoint):
+        Changed QChar to UChar and removed some now-unneeded type casts.
+
+        * editing/RebalanceWhitespaceCommand.cpp: (WebCore::isWhitespace):
+        * editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::doApply):
+        * editing/visible_units.cpp:
+        (WebCore::previousBoundary):
+        (WebCore::nextBoundary):
+        (WebCore::startWordBoundary):
+        (WebCore::endWordBoundary):
+        (WebCore::previousWordPositionBoundary):
+        (WebCore::nextWordPositionBoundary):
+        (WebCore::startSentenceBoundary):
+        (WebCore::endSentenceBoundary):
+        (WebCore::previousSentencePositionBoundary):
+        (WebCore::nextSentencePositionBoundary):
+        (WebCore::startOfParagraph):
+        (WebCore::endOfParagraph):
+        * html/HTMLParser.cpp: (WebCore::HTMLParser::handleError):
+        * rendering/InlineTextBox.cpp:
+        (WebCore::InlineTextBox::selectionRect):
+        (WebCore::InlineTextBox::paint):
+        (WebCore::InlineTextBox::paintSelection):
+        (WebCore::InlineTextBox::paintMarkedTextBackground):
+        (WebCore::InlineTextBox::paintTextMatchMarker):
+        (WebCore::InlineTextBox::offsetForPosition):
+        (WebCore::InlineTextBox::positionForOffset):
+        * rendering/RenderBlock.cpp:
+        (WebCore::stripTrailingSpace):
+        (WebCore::RenderBlock::updateFirstLetter):
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::layoutVerticalBox):
+        * rendering/RenderObject.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::backslashAsCurrencySymbol):
+        * rendering/RenderTreeAsText.cpp: (quoteAndEscapeNonPrintables):
+        * rendering/break_lines.cpp: (WebCore::nextBreakablePosition):
+        * rendering/break_lines.h: (WebCore::isBreakable):
+        * rendering/render_style.h: (WebCore::RenderStyle::isCollapsibleWhiteSpace):
+        * xml/XSLStyleSheet.cpp: (WebCore::XSLStyleSheet::parseString):
+        * xml/xmlhttprequest.cpp:
+        (WebCore::getMIMEType):
+        (WebCore::getCharset):
+        Changed QChar to UChar.
+
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::imageChanged): Changed QChar to UChar.
+        (WebCore::RenderImage::paint): Changed callers of drawText to no-longer pass 0
+        for the horizontal alignment, since I removed that parameters.
+
+        * rendering/RenderText.h: Changed QChar to UChar.
+        * rendering/RenderText.cpp:
+        (WebCore::characterBreakIterator): Update for name change.
+        (WebCore::RenderText::RenderText): Ditto.
+        (WebCore::RenderText::allAscii): Remove uneeded unicode() and allow the value
+        U+007F to count as ASCII.
+        (WebCore::RenderText::cacheWidths): Changed QChar to UChar.
+        (WebCore::RenderText::widthFromCache): Changed code that deals with direction to
+        use the ICU direction calls.
+        (WebCore::RenderText::trimmedMinMaxWidth): Changed QChar to UChar.
+        (WebCore::RenderText::calcMinMaxWidth): Ditto.
+        (WebCore::RenderText::containsOnlyWhitespace): Ditto.
+        (WebCore::RenderText::setText): Ditto.
+        (WebCore::RenderText::width): Ditto.
+
+        * rendering/RenderTextField.cpp:
+        (WebCore::RenderTextField::updateFromElement): Removed unneeded QChar cast.
+        (WebCore::RenderTextField::calcMinMaxWidth): Changed from QChar to UChar.
+
+        * rendering/bidi.h:
+        * rendering/bidi.cpp:
+        (WebCore::BidiIterator::BidiIterator):
+        (WebCore::BidiState::BidiState):
+        (WebCore::BidiContext::BidiContext):
+        (WebCore::bidiNext):
+        (WebCore::bidiFirst):
+        (WebCore::BidiIterator::current):
+        (WebCore::BidiIterator::direction):
+        (WebCore::addRun):
+        (WebCore::checkMidpoints):
+        (WebCore::appendRun):
+        (WebCore::embed):
+        (WebCore::RenderBlock::tabWidth):
+        (WebCore::RenderBlock::computeHorizontalPositionsForLine):
+        (WebCore::RenderBlock::bidiReorderLine):
+        (WebCore::RenderBlock::layoutInlineChildren):
+        (WebCore::skipNonBreakingSpace):
+        (WebCore::RenderBlock::skipWhitespace):
+        (WebCore::RenderBlock::findNextLineBreak):
+        (WebCore::RenderBlock::checkLinesForTextOverflow):
+        Changed from QChar to UChar and all direction from QChar constants to the
+        ones from ICU.
+
+        * rendering/render_form.cpp:
+        (WebCore::RenderLineEdit::updateFromElement):
+        (WebCore::RenderSelect::updateFromElement):
+        (WebCore::RenderTextArea::updateFromElement):
+        (WebCore::RenderTextArea::text):
+        (WebCore::RenderTextArea::textWithHardLineBreaks):
+        Got rid of now-unneeded QChar type casts.
+
+        * rendering/render_line.cpp:
+        (WebCore::InlineFlowBox::placeBoxesHorizontally): Updated for change from QChar
+        to UChar.
+        (WebCore::EllipsisBox::paint): Updated for unicode() -> characters() name change.
+
+        * rendering/render_list.cpp:
+        (WebCore::toRoman): Updated from QChar to UChar.
+        (WebCore::toLetterString): Ditto.
+        (WebCore::toHebrew): More of the same, also cleaned up the logic a bit.
+        (WebCore::RenderListMarker::paint): Removed the alignment parameters from the
+        various functions. Also removed all reliance on the width-measuring functions
+        that take a string.
+        (WebCore::RenderListMarker::calcMinMaxWidth): More of the same.
+        (WebCore::RenderListMarker::getRelativeMarkerRect): Ditto.
+
 2006-05-09  Tim Omernick  <timo@apple.com>
 
         Reviewed by/co-written by Darin.
         * css/html4.css:
         * css/quirks.css:
 
-2006-05-06  Darin Adler  <darin@apple.com>
+2006-05-07  Darin Adler  <darin@apple.com>
         
         Suggested by Mitz. Reviewed and landed by Maciej.
         
index 7d60b27..a9623e0 100644 (file)
@@ -22,6 +22,7 @@
 #include "JSXMLSerializer.h"
 #include "JSXMLSerializer.lut.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "kjs_dom.h"
 #include "markup.h"
index 72c17e3..a630855 100644 (file)
@@ -48,7 +48,7 @@ static String cssPropertyName(const Identifier &p, bool *hadPixelOrPosPrefix = 0
 
     int i = prop.length();
     while (--i) {
-        char c = prop[i].latin1();
+        ::UChar c = prop[i].unicode();
         if (c >= 'A' && c <= 'Z')
             prop.insert(i, '-');
     }
index c5b7ffe..2b681d9 100644 (file)
@@ -158,21 +158,12 @@ JSValue *Navigator::getValueProperty(ExecState *exec, int token) const
   case AppCodeName:
     return jsString("Mozilla");
   case AppName:
-    // If we find "Mozilla" but not "(compatible, ...)" we are a real Netscape
-    if (userAgent.find("Mozilla") >= 0 && userAgent.find("compatible") == -1)
-      return jsString("Netscape");
-    if (userAgent.find("Microsoft") >= 0 || userAgent.find("MSIE") >= 0)
-      return jsString("Microsoft Internet Explorer");
-    return jsUndefined();
+    return jsString("Netscape");
   case AppVersion:
     // We assume the string is something like Mozilla/version (properties)
     return jsString(userAgent.substring(userAgent.find('/') + 1));
   case Product:
-    // When acting normal, we pretend to be "Gecko".
-    if (userAgent.find("Mozilla/5.0") >= 0 && userAgent.find("compatible") == -1)
-        return jsString("Gecko");
-    // When spoofing as IE, we use jsUndefined().
-    return jsUndefined();
+    return jsString("Gecko");
   case ProductSub:
     return jsString("20030107");
   case Vendor:
@@ -184,12 +175,13 @@ JSValue *Navigator::getValueProperty(ExecState *exec, int token) const
   case UserAgent:
     return jsString(userAgent);
   case Platform:
-    if (userAgent.find("Win", 0, false) >= 0)
-      return jsString("Win32");
-    if (userAgent.find("Macintosh", 0, false) >= 0 || userAgent.find("Mac_PowerPC", 0, false) >= 0)
-      return jsString("MacPPC");
-    // FIXME: What about Macintosh Intel?
-    return jsString("X11");
+#if __APPLE__
+    return jsString("MacPPC");
+#elif WIN32
+    return jsString("Win32");
+#else
+    return jsString("");
+#endif
   case _Plugins:
     return new Plugins(exec);
   case _MimeTypes:
index df92fef..f2dea9a 100644 (file)
@@ -34,7 +34,7 @@ using namespace KJS;
 
 namespace WebCore {
 
-KJSProxy::KJSProxy(Frame *frame)
+KJSProxy::KJSProxy(Frameframe)
 {
     m_script = 0;
     m_frame = frame;
@@ -48,7 +48,7 @@ KJSProxy::~KJSProxy()
     Collector::collect();
 }
 
-JSValue* KJSProxy::evaluate(const String& filename, int baseLine, const String& str, Node *n) 
+JSValue* KJSProxy::evaluate(const String& filename, int baseLine, const String& str, Noden) 
 {
   // evaluate code. Returns the JS return value or 0
   // if there was none, an error occured or the type couldn't be converted.
@@ -65,7 +65,7 @@ JSValue* KJSProxy::evaluate(const String& filename, int baseLine, const String&
   JSLock lock;
 
   JSValue* thisNode = n ? Window::retrieve(m_frame) : toJS(m_script->globalExec(), n);
-  Completion comp = m_script->evaluate(filename, baseLine, reinterpret_cast<const KJS::UChar *>(str.unicode()), str.length(), thisNode);
+  Completion comp = m_script->evaluate(filename, baseLine, reinterpret_cast<const KJS::UChar*>(str.characters()), str.length(), thisNode);
 
   if (comp.complType() == Normal || comp.complType() == ReturnValue)
     return comp.value();
@@ -91,7 +91,7 @@ void KJSProxy::clear() {
   }
 }
 
-EventListener* KJSProxy::createHTMLEventHandler(const String& functionName, const String& code, Node *node)
+EventListener* KJSProxy::createHTMLEventHandler(const String& functionName, const String& code, Nodenode)
 {
     initScriptIfNeeded();
     JSLock lock;
@@ -99,7 +99,7 @@ EventListener* KJSProxy::createHTMLEventHandler(const String& functionName, cons
 }
 
 #if SVG_SUPPORT
-EventListener* KJSProxy::createSVGEventHandler(const String& functionName, const String& code, Node *node)
+EventListener* KJSProxy::createSVGEventHandler(const String& functionName, const String& code, Nodenode)
 {
     initScriptIfNeeded();
     JSLock lock;
@@ -107,7 +107,7 @@ EventListener* KJSProxy::createSVGEventHandler(const String& functionName, const
 }
 #endif
 
-void KJSProxy::finishedWithEvent(Event *event)
+void KJSProxy::finishedWithEvent(Eventevent)
 {
   // This is called when the DOM implementation has finished with a particular event. This
   // is the case in sitations where an event has been created just for temporary usage,
@@ -116,7 +116,7 @@ void KJSProxy::finishedWithEvent(Event *event)
   m_script->forgetDOMObject(event);
 }
 
-ScriptInterpreter *KJSProxy::interpreter()
+ScriptInterpreterKJSProxy::interpreter()
 {
   initScriptIfNeeded();
   assert(m_script);
@@ -127,12 +127,12 @@ ScriptInterpreter *KJSProxy::interpreter()
 class TestFunctionImp : public DOMObject {
 public:
   virtual bool implementsCall() const { return true; }
-  virtual JSValue *callAsFunction(ExecState *exec, JSObject *thisObj, const List &args);
+  virtual JSValue* callAsFunction(ExecState*, JSObject*, const List& args);
 };
 
-JSValue *TestFunctionImp::callAsFunction(ExecState *exec, JSObject */*thisObj*/, const List &args)
+JSValue *TestFunctionImp::callAsFunction(ExecState* exec, JSObject*, const List& args)
 {
-  fprintf(stderr,"--> %s\n",args[0]->toString(exec).ascii());
+  fprintf(stderr,"--> %s\n", args[0]->toString(exec).ascii());
   return jsUndefined();
 }
 
index 3dd040a..9a5cd1d 100644 (file)
@@ -1378,7 +1378,7 @@ static void setWindowFeature(const String& keyString, const String& valueString,
 }
 
 // Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
-static bool isSeparator(QChar c)
+static bool isSeparator(UChar c)
 {
     return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ',' || c == '\0';
 }
index ad548c4..e3bb51f 100644 (file)
@@ -100,10 +100,10 @@ void raiseDOMException(ExceptionCode ec)
 
 StringImpl::operator NSString *() const
 {
-    return [NSString stringWithCharacters:reinterpret_cast<const unichar *>(m_data) length:m_length];
+    return [NSString stringWithCharacters:m_data length:m_length];
 }
 
-String::String(NSString *str)
+String::String(NSStringstr)
 {
     if (!str)
         return;
@@ -112,16 +112,9 @@ String::String(NSString *str)
     if (size == 0)
         m_impl = StringImpl::empty();
     else {
-        UniChar fixedSizeBuffer[1024];
-        UniChar *buffer;
-        if (size > static_cast<CFIndex>(sizeof(fixedSizeBuffer) / sizeof(UniChar)))
-            buffer = static_cast<UniChar *>(fastMalloc(size * sizeof(UniChar)));
-        else
-            buffer = fixedSizeBuffer;
-        CFStringGetCharacters(reinterpret_cast<CFStringRef>(str), CFRangeMake(0, size), buffer);
-        m_impl = new StringImpl(reinterpret_cast<const QChar *>(buffer), (unsigned)size);
-        if (buffer != fixedSizeBuffer)
-            fastFree(buffer);
+        Vector<UChar, 1024> buffer(size);
+        CFStringGetCharacters(reinterpret_cast<CFStringRef>(str), CFRangeMake(0, size), buffer.data());
+        m_impl = new StringImpl(buffer.data(), size);
     }
 }
 
index bf165e6..11de414 100644 (file)
 @end
 
 using namespace std;
-
-using namespace KJS;
-using namespace Bindings;
-
+using namespace KJS::Bindings;
 using namespace KIO;
 
+using KJS::JSLock;
+using KJS::PausedTimeouts;
+using KJS::SavedBuiltins;
+using KJS::SavedProperties;
+
 namespace WebCore {
 
 using namespace EventNames;
 using namespace HTMLNames;
 
-NSEvent *FrameMac::_currentEvent = nil;
+NSEventFrameMac::_currentEvent = nil;
 
 static NSMutableDictionary* createNSDictionary(const HashMap<String, String>& map)
 {
@@ -114,7 +116,7 @@ static SEL selectorForKeyEvent(const PlatformKeyboardEvent* event)
         return 0;
 
     SEL selector = NULL;
-    switch (key[0U].unicode()) {
+    switch (key[0U]) {
     case NSUpArrowFunctionKey:
         selector = @selector(moveUp:); break;
     case NSDownArrowFunctionKey:
@@ -632,7 +634,7 @@ void FrameMac::setView(FrameView *view)
 void FrameMac::setTitle(const String &title)
 {
     String text = title;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_bridge setTitle:text];
@@ -642,7 +644,7 @@ void FrameMac::setTitle(const String &title)
 void FrameMac::setStatusBarText(const String& status)
 {
     String text = status;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
     
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_bridge setStatusText:text];
@@ -730,10 +732,10 @@ String FrameMac::advanceToNextMisspelling(bool startBeforeSelection)
 
     while (1) {
         if (!it.atEnd()) {      // we may be starting at the end of the doc, and already by atEnd
-            const QChar *chars = it.characters();
+            const UChar* chars = it.characters();
             int len = it.length();
-            if (len > 1 || !chars[0].isSpace()) {
-                NSString *chunk = [[NSString alloc] initWithCharactersNoCopy:(unichar *)chars length:len freeWhenDone:NO];
+            if (len > 1 || !QChar(chars[0]).isSpace()) {
+                NSString *chunk = [[NSString alloc] initWithCharactersNoCopy:const_cast<UChar*>(chars) length:len freeWhenDone:NO];
                 NSRange misspelling = [checker checkSpellingOfString:chunk startingAt:0 language:nil wrap:NO inSpellDocumentWithTag:[_bridge spellCheckerDocumentTag] wordCount:NULL];
                 [chunk release];
                 if (misspelling.length > 0) {
@@ -1226,7 +1228,7 @@ String FrameMac::incomingReferrer() const
 void FrameMac::runJavaScriptAlert(const String& message)
 {
     String text = message;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_bridge runJavaScriptAlertPanelWithMessage:text];
     END_BLOCK_OBJC_EXCEPTIONS;
@@ -1235,7 +1237,7 @@ void FrameMac::runJavaScriptAlert(const String& message)
 bool FrameMac::runJavaScriptConfirm(const String& message)
 {
     String text = message;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     return [_bridge runJavaScriptConfirmPanelWithMessage:text];
@@ -1247,9 +1249,9 @@ bool FrameMac::runJavaScriptConfirm(const String& message)
 bool FrameMac::runJavaScriptPrompt(const String& prompt, const String& defaultValue, String& result)
 {
     String promptText = prompt;
-    promptText.replace(QChar('\\'), backslashAsCurrencySymbol());
+    promptText.replace('\\', backslashAsCurrencySymbol());
     String defaultValueText = defaultValue;
-    defaultValueText.replace(QChar('\\'), backslashAsCurrencySymbol());
+    defaultValueText.replace('\\', backslashAsCurrencySymbol());
 
     bool ok;
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
@@ -1260,7 +1262,7 @@ bool FrameMac::runJavaScriptPrompt(const String& prompt, const String& defaultVa
 
     if (ok) {
         result = String(returnedText);
-        result.replace(backslashAsCurrencySymbol(), QChar('\\'));
+        result.replace(backslashAsCurrencySymbol(), '\\');
     }
 
     return ok;
@@ -2283,7 +2285,7 @@ NSAttributedString *FrameMac::attributedString(Node *_start, int startOffset, No
                         text += str.mid(runStart, runEnd-runStart);
                         [pendingStyledSpace release];
                         pendingStyledSpace = nil;
-                        addedSpace = str[runEnd-1].direction() == QChar::DirWS;
+                        addedSpace = u_charDirection(str[runEnd - 1].unicode()) == U_WHITE_SPACE_NEUTRAL;
                     }
                     else {
                         RenderText* textObj = static_cast<RenderText*>(renderer);
@@ -2318,7 +2320,7 @@ NSAttributedString *FrameMac::attributedString(Node *_start, int startOffset, No
                                     needSpace = nextRunStart > runEnd;
                                     [pendingStyledSpace release];
                                     pendingStyledSpace = nil;
-                                    addedSpace = str[runEnd-1].direction() == QChar::DirWS;
+                                    addedSpace = u_charDirection(str[runEnd - 1].unicode()) == U_WHITE_SPACE_NEUTRAL;
                                     start = -1;
                                 }
                                 if (end != -1 && runEnd >= end)
@@ -2328,7 +2330,7 @@ NSAttributedString *FrameMac::attributedString(Node *_start, int startOffset, No
                     }
                 }
                 
-                text.replace(QChar('\\'), renderer->backslashAsCurrencySymbol());
+                text.replace('\\', renderer->backslashAsCurrencySymbol());
     
                 if (text.length() > 0 || needSpace) {
                     NSMutableDictionary *attrs = [[NSMutableDictionary alloc] init];
@@ -3105,10 +3107,10 @@ void FrameMac::markMisspellings(const SelectionController &selection)
     WordAwareIterator it(searchRange.get());
     
     while (!it.atEnd()) {      // we may be starting at the end of the doc, and already by atEnd
-        const QChar *chars = it.characters();
+        const UChar* chars = it.characters();
         int len = it.length();
-        if (len > 1 || !chars[0].isSpace()) {
-            NSString *chunk = [[NSString alloc] initWithCharactersNoCopy:(unichar *)chars length:len freeWhenDone:NO];
+        if (len > 1 || !QChar(chars[0]).isSpace()) {
+            NSString *chunk = [[NSString alloc] initWithCharactersNoCopy:const_cast<UChar*>(chars) length:len freeWhenDone:NO];
             int startIndex = 0;
             // Loop over the chunk to find each misspelling in it.
             while (startIndex < len) {
@@ -3402,7 +3404,7 @@ bool FrameMac::shouldClose()
         return true;
 
     String text = event->result();
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     return [_bridge runBeforeUnloadConfirmPanelWithMessage:text];
 
index 1095f6e..927a21b 100644 (file)
@@ -751,14 +751,14 @@ static inline WebCoreFrameBridge *bridge(Frame *frame)
 - (NSString *)selectedString
 {
     String text = m_frame->selectedText();
-    text.replace(QChar('\\'), m_frame->backslashAsCurrencySymbol());
+    text.replace('\\', m_frame->backslashAsCurrencySymbol());
     return [[(NSString*)text copy] autorelease];
 }
 
 - (NSString *)stringForRange:(DOMRange *)range
 {
     String text = plainText([range _range]);
-    text.replace(QChar('\\'), m_frame->backslashAsCurrencySymbol());
+    text.replace('\\', m_frame->backslashAsCurrencySymbol());
     return [[(NSString*)text copy] autorelease];
 }
 
index 7e4e147..2a58c18 100644 (file)
@@ -55,7 +55,7 @@ using namespace HTMLNames;
 
 namespace WebCore {
 
-int getPropertyID(const char *tagStr, int len)
+int getPropertyID(const chartagStr, int len)
 {
     DeprecatedString prop;
 
@@ -78,8 +78,8 @@ int getPropertyID(const char *tagStr, int len)
             len = strlen(opacity);
         }
     }
-    
-    const struct props *propsPtr = findProp(tagStr, len);
+
+    const struct propspropsPtr = findProp(tagStr, len);
     if (!propsPtr)
         return 0;
 
@@ -88,7 +88,7 @@ int getPropertyID(const char *tagStr, int len)
 
 }
 
-static inline int getValueID(const char *tagStr, int len)
+static inline int getValueID(const chartagStr, int len)
 {
     DeprecatedString prop;
     if (len && tagStr[0] == '-') {
@@ -369,7 +369,7 @@ NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {
 ;
 
 maybe_ns_prefix:
-/* empty */ { $$.string = 0; }
+/* empty */ { $$.characters = 0; }
 | IDENT WHITESPACE { $$ = $1; }
 ;
 
@@ -389,12 +389,12 @@ maybe_media_list:
 media_list:
     medium {
         $$ = static_cast<CSSParser*>(parser)->createMediaList();
-        $$->appendMedium( domString($1).lower() );
+        $$->appendMedium(domString($1).lower());
     }
     | media_list ',' maybe_space medium {
         $$ = $1;
         if ($$)
-            $$->appendMedium( domString($4) );
+            $$->appendMedium(domString($4).lower());
     }
     | media_list error {
         $$ = 0;
@@ -529,8 +529,8 @@ selector:
     ;
 
 namespace_selector:
-    /* empty */ '|' { $$.string = 0; $$.length = 0; }
-    | '*' '|' { static unsigned short star = '*'; $$.string = &star; $$.length = 1; }
+    /* empty */ '|' { $$.characters = 0; $$.length = 0; }
+    | '*' '|' { static UChar star = '*'; $$.characters = &star; $$.length = 1; }
     | IDENT '|' { $$ = $1; }
 ;
 
@@ -600,8 +600,8 @@ element_name:
         $$ = str;
     }
     | '*' {
-        static unsigned short star = '*';
-        $$.string = &star;
+        static UChar star = '*';
+        $$.characters = &star;
         $$.length = 1;
     }
   ;
@@ -841,11 +841,14 @@ declaration:
 
 property:
     IDENT maybe_space {
+        $1.lower();
         DeprecatedString str = deprecatedString($1);
-        $$ = getPropertyID(str.lower().latin1(), str.length());
+        const char* s = str.ascii();
+        int l = str.length();
+        $$ = getPropertyID(s, l);
 #if SVG_SUPPORT
-      if ($$ == 0)
-          $$ = SVG::getSVGCSSPropertyID(str.lower().latin1(), str.length());
+        if ($$ == 0)
+            $$ = SVG::getSVGCSSPropertyID(s, l);
 #endif
     }
   ;
index be82539..2a1a004 100644 (file)
@@ -46,9 +46,9 @@ WebCore::String getPropertyName(unsigned short id);
 namespace WebCore {
 
 // Defined in CSSGrammar.y, but not in any header, so just declare it here for now.
-int getPropertyID(const char *str, int len);
+int getPropertyID(const charstr, int len);
 
-static int propertyID(const String &s)
+static int propertyID(const Strings)
 {
     char buffer[maxCSSPropertyNameLength];
 
@@ -57,7 +57,7 @@ static int propertyID(const String &s)
         return 0;
 
     for (unsigned i = 0; i != len; ++i) {
-        unsigned short c = s[i].unicode();
+        UChar c = s[i];
         if (c == 0 || c >= 0x7F)
             return 0; // illegal character
         buffer[i] = c;
@@ -85,7 +85,7 @@ static String quoteStringIfNeeded(const String &string)
     String s = string;
     s.replace('\\', "\\\\");
     s.replace('\'', "\\'");
-    return '\'' + s + '\'';
+    return "'" + s + "'";
 }
 
 CSSStyleDeclaration::CSSStyleDeclaration(CSSRule *parent)
index 6969705..7020f1b 100644 (file)
@@ -26,6 +26,7 @@
 #include "CachedObjectClient.h"
 #include "css_base.h"
 #include "DeprecatedPtrList.h"
+#include "DeprecatedString.h"
 #include "DeprecatedValueList.h"
 #include <wtf/PassRefPtr.h>
 
index ba3c42e..662fd2b 100644 (file)
@@ -38,28 +38,28 @@ String parseURL(const String& url)
     int o = 0;
     int l = i->length();
 
-    while (o < l && (*i)[o].unicode() <= ' ') {
+    while (o < l && (*i)[o] <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
+    while (l > 0 && (*i)[o+l-1] <= ' ')
         --l;
 
     if (l >= 5
-            && (*i)[o].lower() == 'u'
-            && (*i)[o + 1].lower() == 'r'
-            && (*i)[o + 2].lower() == 'l'
+            && ((*i)[o] == 'u' || (*i)[o] == 'U')
+            && ((*i)[o + 1] == 'r' || (*i)[o + 1] == 'R')
+            && ((*i)[o + 2] == 'l' || (*i)[o + 2] == 'L')
             && (*i)[o + 3] == '('
             && (*i)[o + l - 1] == ')') {
         o += 4;
         l -= 5;
     }
 
-    while (o < l && (*i)[o].unicode() <= ' ') {
+    while (o < l && (*i)[o] <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
+    while (l > 0 && (*i)[o+l-1] <= ' ')
         --l;
 
     if (l >= 2 && (*i)[o] == (*i)[o+l-1] && ((*i)[o] == '\'' || (*i)[o] == '\"')) {
@@ -67,23 +67,23 @@ String parseURL(const String& url)
         l -= 2;
     }
 
-    while (o < l && (*i)[o].unicode() <= ' ') {
+    while (o < l && (*i)[o] <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
+    while (l > 0 && (*i)[o+l-1] <= ' ')
         --l;
 
-    Vector<unsigned short, 2048> buffer(l);
+    Vector<UChar, 2048> buffer(l);
 
     int nl = 0;
     for (int k = o; k < o + l; k++) {
-        unsigned short c = (*i)[k].unicode();
+        UChar c = (*i)[k];
         if (c > '\r')
             buffer[nl++] = c;
     }
 
-    return new StringImpl(reinterpret_cast<QChar*>(buffer.data()), nl);
+    return new StringImpl(buffer.data(), nl);
 }
 
 }
index 5619013..6858c72 100644 (file)
@@ -116,19 +116,27 @@ CSSParser::~CSSParser()
 
 void ParseString::lower()
 {
+    // Fast case for all-ASCII.
+    UChar ored = 0;
     for (int i = 0; i < length; i++)
-        string[i] = QChar(string[i]).lower().unicode();
+        ored |= characters[i];
+    if (ored & ~0x7F)
+        for (int i = 0; i < length; i++)
+            characters[i] = u_tolower(characters[i]);
+    else
+        for (int i = 0; i < length; i++)
+            characters[i] = tolower(characters[i]);
 }
 
 void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix)
 {
     int length = string.length() + strlen(prefix) + strlen(suffix) + 2;
     
-    data = (unsigned short*)fastMalloc(length * sizeof(unsigned short));
+    data = static_cast<UChar*>(fastMalloc(length * sizeof(UChar)));
     for (unsigned i = 0; i < strlen(prefix); i++)
         data[i] = prefix[i];
     
-    memcpy(data + strlen(prefix), string.unicode(), string.length() * sizeof(unsigned short));
+    memcpy(data + strlen(prefix), string.characters(), string.length() * sizeof(UChar));
 
     unsigned start = strlen(prefix) + string.length();
     unsigned end = start + strlen(suffix);
@@ -2570,11 +2578,12 @@ static inline int yyerror(const char*) { return 1; }
 
 #include "CSSGrammar.h"
 
-int CSSParser::lex(void *_yylval) {
-    YYSTYPE *yylval = (YYSTYPE *)_yylval;
+int CSSParser::lex(void* yylvalWithoutType)
+{
+    YYSTYPE* yylval = static_cast<YYSTYPE*>(yylvalWithoutType);
     int token = lex();
     int length;
-    unsigned short *t = text(&length);
+    UChar* t = text(&length);
 
 #ifdef TOKEN_DEBUG
     qDebug("CSSTokenizer: got token %d: '%s'", token, token == END_TOKEN ? "" : DeprecatedString((QChar *)t, length).latin1());
@@ -2593,7 +2602,7 @@ int CSSParser::lex(void *_yylval) {
     case DIMEN:
     case UNICODERANGE:
     case FUNCTION:
-        yylval->string.string = t;
+        yylval->string.characters = t;
         yylval->string.length = length;
         break;
 
@@ -2651,9 +2660,9 @@ static inline int toHex(char c)
     return 0;
 }
 
-unsigned short *CSSParser::text(int *length)
+UChar* CSSParser::text(int *length)
 {
-    unsigned short *start = yytext;
+    UChar* start = yytext;
     int l = yyleng;
     switch(yyTok) {
     case STRING:
@@ -2692,11 +2701,11 @@ unsigned short *CSSParser::text(int *length)
     }
 
     // process escapes
-    unsigned short *out = start;
-    unsigned short *escape = 0;
+    UChar* out = start;
+    UChar* escape = 0;
 
     for (int i = 0; i < l; i++) {
-        unsigned short *current = start+i;
+        UChar* current = start + i;
         if (escape == current - 1) {
             if ((*current >= '0' && *current <= '9') ||
                  (*current >= 'a' && *current <= 'f') ||
@@ -2727,7 +2736,7 @@ unsigned short *CSSParser::text(int *length)
             continue;
         if (escape) {
             // add escaped char
-            int uc = 0;
+            unsigned uc = 0;
             escape++;
             while (escape < current) {
                 uc *= 16;
@@ -2737,7 +2746,7 @@ unsigned short *CSSParser::text(int *length)
             // can't handle chars outside ucs2
             if (uc > 0xffff)
                 uc = 0xfffd;
-            *(out++) = (unsigned short)uc;
+            *out++ = uc;
             escape = 0;
             if (*current == ' ' ||
                  *current == '\t' ||
@@ -2750,11 +2759,11 @@ unsigned short *CSSParser::text(int *length)
             escape = current;
             continue;
         }
-        *(out++) = *current;
+        *out++ = *current;
     }
     if (escape) {
         // add escaped char
-        int uc = 0;
+        unsigned uc = 0;
         escape++;
         while (escape < start+l) {
             uc *= 16;
@@ -2764,7 +2773,7 @@ unsigned short *CSSParser::text(int *length)
         // can't handle chars outside ucs2
         if (uc > 0xffff)
             uc = 0xfffd;
-        *(out++) = (unsigned short)uc;
+        *out++ = uc;
     }
     
     *length = out - start;
@@ -2883,6 +2892,11 @@ CSSRule* CSSParser::createStyleRule(CSSSelector* selector)
     return rule;
 }
 
+DeprecatedString deprecatedString(const ParseString& ps)
+{
+    return DeprecatedString(reinterpret_cast<const QChar*>(ps.characters), ps.length);
+}
+
 #define YY_DECL int CSSParser::lex()
 #define yyconst const
 typedef int yy_state_type;
index a1754c5..fc9cae4 100644 (file)
@@ -45,7 +45,7 @@ namespace WebCore {
     class StyleList;
 
     struct ParseString {
-        unsigned short* string;
+        UChar* characters;
         int length;
         
         void lower();
@@ -69,14 +69,12 @@ namespace WebCore {
         int unit;
     };
 
-    static inline DeprecatedString deprecatedString(const ParseString& ps) {
-        return DeprecatedString((QChar *)ps.string, ps.length);
-    }
+    DeprecatedString deprecatedString(const ParseString&);
     static inline String domString(const ParseString& ps) {
-        return String((QChar *)ps.string, ps.length);
+        return String(ps.characters, ps.length);
     }
     static inline AtomicString atomicString(const ParseString& ps) {
-        return AtomicString(ps.string, ps.length);
+        return AtomicString(ps.characters, ps.length);
     }
 
     class ValueList {
@@ -201,7 +199,7 @@ namespace WebCore {
     public:
         int lex(void* yylval);
         int token() { return yyTok; }
-        unsigned short* text(int* length);
+        UChar* text(int* length);
         int lex();
         
     private:
@@ -211,12 +209,12 @@ namespace WebCore {
 
         bool inShorthand() const { return m_inParseShorthand; }
 
-        unsigned short* data;
-        unsigned short* yytext;
-        unsigned short* yy_c_buf_p;
-        unsigned short yy_hold_char;
+        UChar* data;
+        UChar* yytext;
+        UChar* yy_c_buf_p;
+        UChar yy_hold_char;
         int yy_last_accepting_state;
-        unsigned short* yy_last_accepting_cpos;
+        UChar* yy_last_accepting_cpos;
         int yyleng;
         int yyTok;
         int yy_start;
index 1405afc..96ebf0c 100644 (file)
@@ -556,7 +556,7 @@ static void checkPseudoState(Element *e, bool checkVisited = true)
         return;
     }
     
-    QConstString cu(attr.unicode(), attr.length());
+    QConstString cu(reinterpret_cast<const QChar*>(attr.characters()), attr.length());
     DeprecatedString u = cu.string();
     if (!u.contains("://")) {
         if (u[0] == '/')
index 5359a52..fb76246 100644 (file)
@@ -44,7 +44,7 @@ CharacterData::CharacterData(Document *doc)
 CharacterData::CharacterData(Document *doc, const String &_text)
     : EventTargetNode(doc)
 {
-    str = _text.impl() ? _text.impl() : new StringImpl((QChar*)0, 0);
+    str = _text.impl() ? _text.impl() : new StringImpl(static_cast<UChar*>(0), 0);
     str->ref();
 }
 
index 80b955a..2d1f512 100644 (file)
@@ -2392,7 +2392,7 @@ void Document::setDomain(const String &newDomain, bool force /*=false*/)
 
 bool Document::isValidName(const String &name)
 {
-    const UChar *s = reinterpret_cast<const UChar *>(name.unicode());
+    const UChar* s = reinterpret_cast<const UChar*>(name.characters());
     unsigned length = name.length();
 
     if (length == 0)
@@ -2425,7 +2425,7 @@ bool Document::parseQualifiedName(const String &qualifiedName, String &prefix, S
     bool sawColon = false;
     int colonPos = 0;
 
-    const UChar* s = reinterpret_cast<const UChar*>(qualifiedName.unicode());
+    const UChar* s = reinterpret_cast<const UChar*>(qualifiedName.characters());
     for (unsigned i = 0; i < length;) {
         UChar32 c;
         U16_NEXT(s, i, length, c)
@@ -2489,7 +2489,7 @@ void Document::setDecoder(Decoder *decoder)
     m_decoder = decoder;
 }
 
-QChar Document::backslashAsCurrencySymbol() const
+UChar Document::backslashAsCurrencySymbol() const
 {
     if (!m_decoder)
         return '\\';
@@ -3098,21 +3098,20 @@ Vector<String> Document::formElementsState() const
 }
 
 #if XPATH_SUPPORT
+
 PassRefPtr<XPathExpression> Document::createExpression(const String& expression,
                                                        XPathNSResolver* resolver,
                                                        ExceptionCode& ec)
 {
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->createExpression(expression, resolver, ec);
 }
 
-PassRefPtr<XPathNSResolver> Document::createNSResolver(Node *nodeResolver)
+PassRefPtr<XPathNSResolver> Document::createNSResolver(NodenodeResolver)
 {
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->createNSResolver(nodeResolver);
 }
 
@@ -3125,7 +3124,6 @@ PassRefPtr<XPathResult> Document::evaluate(const String& expression,
 {
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->evaluate(expression, contextNode, resolver, type, result, ec);
 }
 
index 7c443f7..6b5e32b 100644 (file)
@@ -705,7 +705,7 @@ public:
     void setDecoder(Decoder*);
     Decoder* decoder() const { return m_decoder.get(); }
 
-    QChar backslashAsCurrencySymbol() const;
+    UChar backslashAsCurrencySymbol() const;
 
 #if __APPLE__
     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
index 28e5183..f1eee56 100644 (file)
@@ -76,7 +76,7 @@ bool NamedMappedAttrMap::mapsEquivalent(const NamedMappedAttrMap* otherMap) cons
     return true;
 }
 
-inline static bool isClassWhitespace(QChar c)
+inline static bool isClassWhitespace(UChar c)
 {
     return c == ' ' || c == '\r' || c == '\n' || c == '\t';
 }
@@ -93,7 +93,7 @@ void NamedMappedAttrMap::parseClassAttribute(const String& classStr)
     
     AtomicStringList* curr = 0;
     
-    const QChar* str = classAttr.unicode();
+    const UChar* str = classAttr.characters();
     int length = classAttr.length();
     int sPos = 0;
 
index 0ee81c8..2ba2210 100644 (file)
@@ -40,6 +40,8 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
+const UChar nonBreakingSpace = 0xa0;
+
 static Node *nextRenderedEditable(Node *node)
 {
     while (1) {
@@ -626,8 +628,8 @@ Position Position::leadingWhitespacePosition(EAffinity affinity, bool considerNo
     Position prev = previousCharacterPosition(affinity);
     if (prev != *this && prev.node()->inSameContainingBlockFlowElement(node()) && prev.node()->isTextNode()) {
         String string = static_cast<Text *>(prev.node())->data();
-        const QChar &c = string[prev.offset()];
-        if (considerNonCollapsibleWhitespace ? (c.isSpace() || c.unicode() == 0xa0) : isCollapsibleWhitespace(c))
+        UChar c = string[prev.offset()];
+        if (considerNonCollapsibleWhitespace ? (QChar(c).isSpace() || c == nonBreakingSpace) : isCollapsibleWhitespace(c))
             return prev;
     }
 
@@ -640,11 +642,11 @@ Position Position::trailingWhitespacePosition(EAffinity affinity, bool considerN
         return Position();
 
     if (node()->isTextNode()) {
-        Text *textNode = static_cast<Text *>(node());
+        Text* textNode = static_cast<Text*>(node());
         if (offset() < (int)textNode->length()) {
-            String string = static_cast<Text *>(node())->data();
-            const QChar &c = string[offset()];
-            if (considerNonCollapsibleWhitespace ? (c.isSpace() || c.unicode() == 0xa0) : isCollapsibleWhitespace(c))
+            String string = textNode->data();
+            UChar c = string[offset()];
+            if (considerNonCollapsibleWhitespace ? (QChar(c).isSpace() || c == nonBreakingSpace) : isCollapsibleWhitespace(c))
                 return *this;
             return Position();
         }
@@ -655,9 +657,9 @@ Position Position::trailingWhitespacePosition(EAffinity affinity, bool considerN
 
     Position next = nextCharacterPosition(affinity);
     if (next != *this && next.node()->inSameContainingBlockFlowElement(node()) && next.node()->isTextNode()) {
-        String string = static_cast<Text *>(next.node())->data();
-        const QChar &c = string[0];
-        if (considerNonCollapsibleWhitespace ? (c.isSpace() || c.unicode() == 0xa0) : isCollapsibleWhitespace(c))
+        String string = static_cast<Text*>(next.node())->data();
+        UChar c = string[0];
+        if (considerNonCollapsibleWhitespace ? (QChar(c).isSpace() || c == nonBreakingSpace) : isCollapsibleWhitespace(c))
             return next;
     }
 
index aa7bbd2..aa0d887 100644 (file)
@@ -101,7 +101,7 @@ void StyledElement::updateStyleAttributeIfNeeded() const
     }
 }
 
-inline static bool isClassWhitespace(QChar c)
+inline static bool isClassWhitespace(UChar c)
 {
     return c == ' ' || c == '\r' || c == '\n' || c == '\t';
 }
@@ -295,11 +295,11 @@ void StyledElement::addCSSLength(MappedAttribute* attr, int id, const String &va
     if (v) {
         unsigned int l = 0;
         
-        while (l < v->length() && (*v)[l].unicode() <= ' ')
+        while (l < v->length() && (*v)[l] <= ' ')
             l++;
         
         for (; l < v->length(); l++) {
-            char cc = (*v)[l].latin1();
+            UChar cc = (*v)[l];
             if (cc > '9' || (cc < '0' && cc != '*' && cc != '%' && cc != '.'))
                 break;
         }
@@ -358,7 +358,7 @@ void StyledElement::addCSSColor(MappedAttribute* attr, int id, const String &c)
                 // search forward for digits in the string
                 int numDigits = 0;
                 while (pos < (int)color.length() && numDigits < basicLength) {
-                    int hex = toHex(color[pos].unicode());
+                    int hex = toHex(color[pos]);
                     colors[component] = (colors[component] << 4);
                     if (hex > 0) {
                         colors[component] += hex;
index 8f5bd0e..d85a463 100644 (file)
@@ -513,7 +513,7 @@ int KeyboardEvent::charCode() const
     String text = m_keyEvent->text();
     if (text.length() != 1)
         return 0;
-    return text[0].unicode();
+    return text[0];
 }
 
 bool KeyboardEvent::isKeyboardEvent() const
index 1c829bc..ed9f309 100644 (file)
@@ -62,7 +62,7 @@ protected:
 
 Tokenizer* newXMLTokenizer(Document*, FrameView* = 0);
 #if KHTML_XSLT
-void* xmlDocPtrForString(const DeprecatedString& source, const DeprecatedString& URL = DeprecatedString());
+void* xmlDocPtrForString(const DeprecatedString& source, const DeprecatedString& URL);
 void setLoaderForLibXMLCallbacks(DocLoader*);
 #endif
 HashMap<String, String> parseAttributes(const String&, bool& attrsOK);
index 7027670..8a12376 100644 (file)
@@ -61,10 +61,10 @@ DeprecatedString convertHTMLTextToInterchangeFormat(const DeprecatedString &in)
     unsigned int consumed = 0;
     while (i < in.length()) {
         consumed = 1;
-        if (isCollapsibleWhitespace(in[i])) {
+        if (isCollapsibleWhitespace(in[i].unicode())) {
             // count number of adjoining spaces
             unsigned int j = i + 1;
-            while (j < in.length() && isCollapsibleWhitespace(in[j]))
+            while (j < in.length() && isCollapsibleWhitespace(in[j].unicode()))
                 j++;
             unsigned int count = j - i;
             consumed = count;
index 27d117d..a6a2809 100644 (file)
@@ -80,11 +80,6 @@ Position InsertTextCommand::prepareForTextInsertion(const Position& pos)
     return pos;
 }
 
-static inline bool isNBSP(const QChar &c)
-{
-    return c.unicode() == 0xa0;
-}
-
 void InsertTextCommand::input(const String &text, bool selectInsertedText)
 {
     assert(text.find('\n') == -1);
index 0bd8ee4..e24b2fc 100644 (file)
@@ -38,9 +38,9 @@ RebalanceWhitespaceCommand::RebalanceWhitespaceCommand(Document *document, const
 {
 }
 
-static inline bool isWhitespace(const QChar &c)
+static inline bool isWhitespace(UChar c)
 {
-    return c.unicode() == 0xa0 || isCollapsibleWhitespace(c);
+    return c == 0xa0 || isCollapsibleWhitespace(c);
 }
 
 // FIXME: This doesn't go into adjacent text in siblings, cousins, etc.
index 9a05ed7..69fb4d1 100644 (file)
@@ -619,14 +619,14 @@ void ReplaceSelectionCommand::doApply()
         assert(visiblePos.isNotNull());
         addLeadingSpace = startPos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isStartOfParagraph(visiblePos);
         if (addLeadingSpace) {
-            QChar previousChar = visiblePos.previous().characterAfter();
-            if (previousChar.unicode())
+            UChar previousChar = visiblePos.previous().characterAfter();
+            if (previousChar)
                 addLeadingSpace = !frame->isCharacterSmartReplaceExempt(previousChar, true);
         }
         addTrailingSpace = startPos.trailingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isEndOfParagraph(visiblePos);
         if (addTrailingSpace) {
-            QChar thisChar = visiblePos.characterAfter();
-            if (thisChar.unicode())
+            UChar thisChar = visiblePos.characterAfter();
+            if (thisChar)
                 addTrailingSpace = !frame->isCharacterSmartReplaceExempt(thisChar, false);
         }
     }
index 0180496..00c0663 100644 (file)
@@ -43,7 +43,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
-const unsigned short nonBreakingSpace = 0xA0;
+const UChar nonBreakingSpace = 0xA0;
 
 // Buffer that knows how to compare with a search target.
 // Keeps enough of the previous text to be able to search in the future,
@@ -54,8 +54,8 @@ public:
     ~CircularSearchBuffer() { fastFree(m_buffer); }
 
     void clear() { m_cursor = m_buffer; m_bufferFull = false; }
-    void append(int length, const QChar *characters);
-    void append(const QChar&);
+    void append(int length, const UChar* characters);
+    void append(UChar);
 
     int neededCharacters() const;
     bool isMatch() const;
@@ -65,15 +65,15 @@ private:
     String m_target;
     bool m_isCaseSensitive;
 
-    QChar *m_buffer;
-    QChar *m_cursor;
+    UChar* m_buffer;
+    UChar* m_cursor;
     bool m_bufferFull;
 
     CircularSearchBuffer(const CircularSearchBuffer&);
     CircularSearchBuffer &operator=(const CircularSearchBuffer&);
 };
 
-TextIterator::TextIterator() : m_endContainer(0), m_endOffset(0), m_positionNode(0)
+TextIterator::TextIterator() : m_endContainer(0), m_endOffset(0), m_positionNode(0), m_lastCharacter(0)
 {
 }
 
@@ -229,7 +229,7 @@ bool TextIterator::handleTextNode()
         m_positionOffsetBaseNode = 0;
         m_positionStartOffset = runStart;
         m_positionEndOffset = runEnd;
-        m_textCharacters = str.unicode() + runStart;
+        m_textCharacters = str.characters() + runStart;
         m_textLength = runEnd - runStart;
 
         m_lastCharacter = str[runEnd - 1];
@@ -271,7 +271,7 @@ void TextIterator::handleTextBox()
         InlineTextBox *firstTextBox = renderer->containsReversedText() ? m_sortedTextBoxes[0] : renderer->firstTextBox();
         bool needSpace = m_lastTextNodeEndedWithCollapsedSpace
             || (m_textBox == firstTextBox && textBoxStart == runStart && runStart > 0);
-        if (needSpace && !isCollapsibleWhitespace(m_lastCharacter) && m_lastCharacter.unicode()) {
+        if (needSpace && !isCollapsibleWhitespace(m_lastCharacter) && m_lastCharacter) {
             emitCharacter(' ', m_node, 0, runStart, runStart);
             return;
         }
@@ -304,7 +304,7 @@ void TextIterator::handleTextBox()
                 m_positionOffsetBaseNode = 0;
                 m_positionStartOffset = runStart;
                 m_positionEndOffset = subrunEnd;
-                m_textCharacters = str.unicode() + runStart;
+                m_textCharacters = str.characters() + runStart;
                 m_textLength = subrunEnd - runStart;
 
                 m_lastTextNodeEndedWithCollapsedSpace = false;
@@ -505,7 +505,7 @@ void TextIterator::exitNode()
         emitCharacter(' ', m_node->parentNode(), m_node, 1, 1);
 }
 
-void TextIterator::emitCharacter(QChar c, Node *textNode, Node *offsetBaseNode, int textStartOffset, int textEndOffset)
+void TextIterator::emitCharacter(UChar c, Node *textNode, Node *offsetBaseNode, int textStartOffset, int textEndOffset)
 {
     // remember information with which to construct the TextIterator::range()
     // NOTE: textNode is often not a text node, so the range will specify child nodes of positionNode
@@ -689,7 +689,7 @@ bool SimplifiedBackwardsTextIterator::handleTextNode()
     m_positionNode = m_node;
     m_positionStartOffset = m_offset;
     m_textLength = m_positionEndOffset - m_positionStartOffset;
-    m_textCharacters = str.unicode() + m_positionStartOffset;
+    m_textCharacters = str.characters() + m_positionStartOffset;
 
     m_lastCharacter = str[m_positionEndOffset - 1];
 
@@ -734,7 +734,7 @@ void SimplifiedBackwardsTextIterator::exitNode()
     handleNonTextNode();
 }
 
-void SimplifiedBackwardsTextIterator::emitCharacter(QChar c, Node *node, int startOffset, int endOffset)
+void SimplifiedBackwardsTextIterator::emitCharacter(UChar c, Node *node, int startOffset, int endOffset)
 {
     m_singleCharacterBuffer = c;
     m_positionNode = node;
@@ -843,7 +843,7 @@ DeprecatedString CharacterIterator::string(int numChars)
     result.reserve(numChars);
     while (numChars > 0 && !atEnd()) {
         int runSize = min(numChars, length());
-        result.append(characters(), runSize);
+        result.append(reinterpret_cast<const QChar*>(characters()), runSize);
         numChars -= runSize;
         advance(runSize);
     }
@@ -894,7 +894,7 @@ void WordAwareIterator::advance()
     
     while (1) {
         // If this chunk ends in whitespace we can just use it as our chunk.
-        if (m_textIterator.characters()[m_textIterator.length()-1].isSpace())
+        if (QChar(m_textIterator.characters()[m_textIterator.length() - 1]).isSpace())
             return;
 
         // If this is the first chunk that failed, save it in previousText before look ahead
@@ -905,17 +905,17 @@ void WordAwareIterator::advance()
 
         // Look ahead to next chunk.  If it is whitespace or a break, we can use the previous stuff
         m_textIterator.advance();
-        if (m_textIterator.atEnd() || m_textIterator.length() == 0 || m_textIterator.characters()[0].isSpace()) {
+        if (m_textIterator.atEnd() || m_textIterator.length() == 0 || QChar(m_textIterator.characters()[0]).isSpace()) {
             m_didLookAhead = true;
             return;
         }
 
         if (m_buffer.isEmpty()) {
             // Start gobbling chunks until we get to a suitable stopping point
-            m_buffer.append(m_previousText, m_previousLength);
+            m_buffer.append(reinterpret_cast<const QChar*>(m_previousText), m_previousLength);
             m_previousText = 0;
         }
-        m_buffer.append(m_textIterator.characters(), m_textIterator.length());
+        m_buffer.append(reinterpret_cast<const QChar*>(m_textIterator.characters()), m_textIterator.length());
         int exception = 0;
         m_range->setEnd(m_textIterator.range()->endContainer(exception), m_textIterator.range()->endOffset(exception), exception);
     }
@@ -925,20 +925,18 @@ int WordAwareIterator::length() const
 {
     if (!m_buffer.isEmpty())
         return m_buffer.length();
-    else if (m_previousText)
+    if (m_previousText)
         return m_previousLength;
-    else
-        return m_textIterator.length();
+    return m_textIterator.length();
 }
 
-const QChar *WordAwareIterator::characters() const
+const UChar* WordAwareIterator::characters() const
 {
     if (!m_buffer.isEmpty())
-        return m_buffer.unicode();
-    else if (m_previousText)
+        return reinterpret_cast<const UChar*>(m_buffer.unicode());
+    if (m_previousText)
         return m_previousText;
-    else
-        return m_textIterator.characters();
+    return m_textIterator.characters();
 }
 
 CircularSearchBuffer::CircularSearchBuffer(const String& s, bool isCaseSensitive)
@@ -947,21 +945,21 @@ CircularSearchBuffer::CircularSearchBuffer(const String& s, bool isCaseSensitive
     assert(!s.isEmpty());
 
     if (!isCaseSensitive)
-        m_target = s.lower();
+        m_target = s.foldCase();
     m_target.replace(nonBreakingSpace, ' ');
     m_isCaseSensitive = isCaseSensitive;
 
-    m_buffer = static_cast<QChar *>(fastMalloc(s.length() * sizeof(QChar)));
+    m_buffer = static_cast<UChar*>(fastMalloc(s.length() * sizeof(UChar)));
     m_cursor = m_buffer;
     m_bufferFull = false;
 }
 
-void CircularSearchBuffer::append(const QChar &c)
+void CircularSearchBuffer::append(UChar c)
 {
     if (m_isCaseSensitive)
-        *m_cursor++ = c.unicode() == nonBreakingSpace ? ' ' : c.unicode();
+        *m_cursor++ = c == nonBreakingSpace ? ' ' : c;
     else
-        *m_cursor++ = c.unicode() == nonBreakingSpace ? ' ' : c.lower().unicode();
+        *m_cursor++ = c == nonBreakingSpace ? ' ' : u_foldCase(c, U_FOLD_CASE_DEFAULT);
     if (m_cursor == m_buffer + length()) {
         m_cursor = m_buffer;
         m_bufferFull = true;
@@ -971,7 +969,7 @@ void CircularSearchBuffer::append(const QChar &c)
 // This function can only be used when the buffer is not yet full,
 // and when then count is small enough to fit in the buffer.
 // No need for a more general version for the search algorithm.
-void CircularSearchBuffer::append(int count, const QChar *characters)
+void CircularSearchBuffer::append(int count, const UChar* characters)
 {
     int tailSpace = m_buffer + length() - m_cursor;
 
@@ -980,13 +978,13 @@ void CircularSearchBuffer::append(int count, const QChar *characters)
 
     if (m_isCaseSensitive) {
         for (int i = 0; i != count; ++i) {
-            QChar c = characters[i];
-            m_cursor[i] = c.unicode() == nonBreakingSpace ? ' ' : c.unicode();
+            UChar c = characters[i];
+            m_cursor[i] = c == nonBreakingSpace ? ' ' : c;
         }
     } else {
         for (int i = 0; i != count; ++i) {
-            QChar c = characters[i];
-            m_cursor[i] = c.unicode() == nonBreakingSpace ? ' ' : c.lower().unicode();
+            UChar c = characters[i];
+            m_cursor[i] = c == nonBreakingSpace ? ' ' : u_foldCase(c, U_FOLD_CASE_DEFAULT);
         }
     }
     if (count < tailSpace)
@@ -1008,8 +1006,8 @@ bool CircularSearchBuffer::isMatch() const
 
     int headSpace = m_cursor - m_buffer;
     int tailSpace = length() - headSpace;
-    return memcmp(m_cursor, m_target.unicode(), tailSpace * sizeof(QChar)) == 0
-        && memcmp(m_buffer, m_target.unicode() + tailSpace, headSpace * sizeof(QChar)) == 0;
+    return memcmp(m_cursor, m_target.characters(), tailSpace * sizeof(UChar)) == 0
+        && memcmp(m_buffer, m_target.characters() + tailSpace, headSpace * sizeof(UChar)) == 0;
 }
 
 int TextIterator::rangeLength(const Range *r)
@@ -1094,12 +1092,11 @@ PassRefPtr<Range> TextIterator::rangeFromLocationAndLength(Document *doc, int ra
     return resultRange.release();
 }
 
-DeprecatedString plainText(const Range *r)
+DeprecatedString plainText(const Ranger)
 {
     DeprecatedString result("");
-    for (TextIterator it(r); !it.atEnd(); it.advance()) {
-        result.append(it.characters(), it.length());
-    }
+    for (TextIterator it(r); !it.atEnd(); it.advance())
+        result.append(reinterpret_cast<const QChar*>(it.characters()), it.length());
     return result;
 }
 
index 592cc31..eb23553 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -35,9 +35,9 @@ namespace WebCore {
 // FIXME: Can't really answer this question correctly without knowing the white-space mode.
 // FIXME: Move this along with the white-space position functions above
 // somewhere else in the editing directory. It doesn't belong here.
-inline bool isCollapsibleWhitespace(const QChar& c)
+inline bool isCollapsibleWhitespace(UChar c)
 {
-    switch (c.unicode()) {
+    switch (c) {
         case ' ':
         case '\n':
             return true;
@@ -65,7 +65,7 @@ public:
     void advance();
     
     int length() const { return m_textLength; }
-    const QChar *characters() const { return m_textCharacters; }
+    const UChar* characters() const { return m_textCharacters; }
     
     PassRefPtr<Range> range() const;
      
@@ -78,7 +78,7 @@ private:
     bool handleReplacedElement();
     bool handleNonTextNode();
     void handleTextBox();
-    void emitCharacter(QChar, Node *textNode, Node *offsetBaseNode, int textStartOffset, int textEndOffset);
+    void emitCharacter(UChar, Node *textNode, Node *offsetBaseNode, int textStartOffset, int textEndOffset);
     
     // Current position, not necessarily of the text being returned, but position
     // as we walk through the DOM tree.
@@ -97,7 +97,7 @@ private:
     mutable Node *m_positionOffsetBaseNode;
     mutable int m_positionStartOffset;
     mutable int m_positionEndOffset;
-    const QChar *m_textCharacters;
+    const UChar* m_textCharacters;
     int m_textLength;
     
     // Used when there is still some pending text from the current node; when these
@@ -108,10 +108,10 @@ private:
     // Used to do the whitespace collapsing logic.
     Node *m_lastTextNode;    
     bool m_lastTextNodeEndedWithCollapsedSpace;
-    QChar m_lastCharacter;
+    UChar m_lastCharacter;
     
     // Used for whitespace characters that aren't in the DOM, so we can point at them.
-    QChar m_singleCharacterBuffer;
+    UChar m_singleCharacterBuffer;
     
     // Used when text boxes are out of order (Hebrew/Arabic w/ embeded LTR text)
     Vector<InlineTextBox*> m_sortedTextBoxes;
@@ -131,7 +131,7 @@ public:
     void advance();
     
     int length() const { return m_textLength; }
-    const QChar *characters() const { return m_textCharacters; }
+    const UChar* characters() const { return m_textCharacters; }
     
     PassRefPtr<Range> range() const;
         
@@ -140,33 +140,33 @@ private:
     bool handleTextNode();
     bool handleReplacedElement();
     bool handleNonTextNode();
-    void emitCharacter(QChar, Node *Node, int startOffset, int endOffset);
+    void emitCharacter(UChar, Node *Node, int startOffset, int endOffset);
     void emitNewline();
     
     // Current position, not necessarily of the text being returned, but position
     // as we walk through the DOM tree.
-    Node *m_node;
+    Nodem_node;
     int m_offset;
     bool m_handledNode;
     bool m_handledChildren;
     
     // End of the range.
-    Node *m_startNode;
+    Nodem_startNode;
     int m_startOffset;
     
     // The current text and its position, in the form to be returned from the iterator.
-    Node *m_positionNode;
+    Nodem_positionNode;
     int m_positionStartOffset;
     int m_positionEndOffset;
-    const QChar *m_textCharacters;
+    const UChar* m_textCharacters;
     int m_textLength;
 
     // Used to do the whitespace logic.
-    Node *m_lastTextNode;    
-    QChar m_lastCharacter;
+    Nodem_lastTextNode;    
+    UChar m_lastCharacter;
     
     // Used for whitespace characters that aren't in the DOM, so we can point at them.
-    QChar m_singleCharacterBuffer;
+    UChar m_singleCharacterBuffer;
 };
 
 // Builds on the text iterator, adding a character position so we can walk one
@@ -182,7 +182,7 @@ public:
     bool atEnd() const { return m_textIterator.atEnd(); }
     
     int length() const { return m_textIterator.length() - m_runOffset; }
-    const QChar *characters() const { return m_textIterator.characters() + m_runOffset; }
+    const UChar* characters() const { return m_textIterator.characters() + m_runOffset; }
     DeprecatedString string(int numChars);
     
     int characterOffset() const { return m_offset; }
@@ -207,14 +207,14 @@ public:
     void advance();
     
     int length() const;
-    const QChar *characters() const;
+    const UChar* characters() const;
     
     // Range of the text we're currently returning
     PassRefPtr<Range> range() const { return m_range; }
 
 private:
     // text from the previous chunk from the textIterator
-    const QChar *m_previousText;
+    const UChar* m_previousText;
     int m_previousLength;
 
     // many chunks from textIterator concatenated
index 156b61a..e1c831e 100644 (file)
@@ -198,20 +198,18 @@ int VisiblePosition::maxOffset(const Node *node)
     return node->offsetInCharacters() ? (int)static_cast<const CharacterData *>(node)->length() : (int)node->childNodeCount();
 }
 
-QChar VisiblePosition::characterAfter() const
+UChar VisiblePosition::characterAfter() const
 {
     // We canonicalize to the first of two equivalent candidates, but the second of the two candidates
     // is the one that will be inside the text node containing the character after this visible position.
     Position pos = m_deepPosition.downstream();
-    Node *node = pos.node();
-    if (!node || !node->isTextNode()) {
-        return QChar();
-    }
-    Text *textNode = static_cast<Text *>(pos.node());
+    Node* node = pos.node();
+    if (!node || !node->isTextNode())
+        return 0;
+    Text* textNode = static_cast<Text*>(pos.node());
     int offset = pos.offset();
-    if ((unsigned)offset >= textNode->length()) {
-        return QChar();
-    }
+    if ((unsigned)offset >= textNode->length())
+        return 0;
     return textNode->data()[offset];
 }
 
index 3cc4649..dcf2300 100644 (file)
@@ -66,7 +66,7 @@ public:
 
     bool isLastInBlock() const;
 
-    QChar characterAfter() const;
+    UChar characterAfter() const;
     
     void debugPosition(const char* msg = "") const;
     
index 9542e03..02253b5 100644 (file)
@@ -54,7 +54,7 @@ static DeprecatedString escapeTextForMarkup(const DeprecatedString &in)
 
     unsigned len = in.length();
     for (unsigned i = 0; i < len; ++i) {
-        switch (in[i].latin1()) {
+        switch (in[i].unicode()) {
             case '&':
                 s += "&amp;";
                 break;
index 49426b9..4306368 100644 (file)
@@ -38,7 +38,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
-static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
+static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const UChar *, unsigned))
 {
     Position pos = c.deepEquivalent();
     Node *n = pos.node();
@@ -72,8 +72,8 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
     unsigned next = 0;
     while (!it.atEnd() && it.length() > 0) {
         // iterate to get chunks until the searchFunction returns a non-zero value.
-        string.prepend(it.characters(), it.length());
-        next = searchFunction(string.unicode(), string.length());
+        string.prepend(reinterpret_cast<const QChar*>(it.characters()), it.length());
+        next = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
         if (next != 0)
             break;
         it.advance();
@@ -92,7 +92,7 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
         chars[0] = 'X';
         chars[1] = ' ';
         string.prepend(chars, 2);
-        unsigned pastImage = searchFunction(string.unicode(), string.length());
+        unsigned pastImage = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
         RefPtr<Range> range(it.range());
         if (pastImage == 0)
             pos = Position(range->startContainer(exception), range->startOffset(exception));
@@ -115,7 +115,7 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
     return VisiblePosition(pos, DOWNSTREAM);
 }
 
-static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
+static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const UChar *, unsigned))
 {
     Position pos = c.deepEquivalent();
     Node *n = pos.node();
@@ -143,8 +143,8 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
     while (!it.atEnd() && it.length() > 0) {
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to it.
-        string.append(it.characters(), it.length());
-        next = searchFunction(string.unicode(), string.length());
+        string.append(reinterpret_cast<const QChar*>(it.characters()), it.length());
+        next = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
         if (next != string.length())
             break;
         it.advance();
@@ -164,7 +164,7 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
         chars[0] = ' ';
         chars[1] = 'X';
         string.append(chars, 2);
-        unsigned pastImage = searchFunction(string.unicode(), string.length());
+        unsigned pastImage = searchFunction(reinterpret_cast<const UChar*>(string.unicode()), string.length());
         RefPtr<Range> range(it.range());
         int exception = 0;
         if (next != pastImage)
@@ -184,7 +184,7 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
 
 // ---------
 
-static unsigned startWordBoundary(const QChar *characters, unsigned length)
+static unsigned startWordBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
     findWordBoundary(characters, length, length, &start, &end);
@@ -206,7 +206,7 @@ VisiblePosition startOfWord(const VisiblePosition &c, EWordSide side)
     return previousBoundary(p, startWordBoundary);
 }
 
-static unsigned endWordBoundary(const QChar *characters, unsigned length)
+static unsigned endWordBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
     findWordBoundary(characters, length, 0, &start, &end);
@@ -234,7 +234,7 @@ VisiblePosition endOfWord(const VisiblePosition &c, EWordSide side)
     return nextBoundary(p, endWordBoundary);
 }
 
-static unsigned previousWordPositionBoundary(const QChar *characters, unsigned length)
+static unsigned previousWordPositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextWordFromIndex(characters, length, length, false);
 }
@@ -244,7 +244,7 @@ VisiblePosition previousWordPosition(const VisiblePosition &c)
     return previousBoundary(c, previousWordPositionBoundary);
 }
 
-static unsigned nextWordPositionBoundary(const QChar *characters, unsigned length)
+static unsigned nextWordPositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextWordFromIndex(characters, length, 0, true);
 }
@@ -490,7 +490,7 @@ VisiblePosition nextLinePosition(const VisiblePosition &visiblePosition, int x)
 
 // ---------
 
-static unsigned startSentenceBoundary(const QChar *characters, unsigned length)
+static unsigned startSentenceBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
     findSentenceBoundary(characters, length, length, &start, &end);
@@ -502,7 +502,7 @@ VisiblePosition startOfSentence(const VisiblePosition &c)
     return previousBoundary(c, startSentenceBoundary);
 }
 
-static unsigned endSentenceBoundary(const QChar *characters, unsigned length)
+static unsigned endSentenceBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
     findSentenceBoundary(characters, length, 0, &start, &end);
@@ -514,7 +514,7 @@ VisiblePosition endOfSentence(const VisiblePosition &c)
     return nextBoundary(c, endSentenceBoundary);
 }
 
-static unsigned previousSentencePositionBoundary(const QChar *characters, unsigned length)
+static unsigned previousSentencePositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextSentenceFromIndex(characters, length, length, false);
 }
@@ -524,7 +524,7 @@ VisiblePosition previousSentencePosition(const VisiblePosition &c)
     return previousBoundary(c, previousSentencePositionBoundary);
 }
 
-static unsigned nextSentencePositionBoundary(const QChar *characters, unsigned length)
+static unsigned nextSentencePositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextSentenceFromIndex(characters, length, 0, true);
 }
@@ -563,7 +563,7 @@ VisiblePosition startOfParagraph(const VisiblePosition &c)
             break;
         if (r->isText()) {
             if (style->preserveNewline()) {
-                const QChar* text = static_cast<RenderText*>(r)->text();
+                const UChar* text = static_cast<RenderText*>(r)->text();
                 int i = static_cast<RenderText*>(r)->length();
                 int o = offset;
                 if (n == startNode && o < i)
@@ -623,7 +623,7 @@ VisiblePosition endOfParagraph(const VisiblePosition &c)
         if (r->isText() && r->caretMaxRenderedOffset() > 0) {
             int length = static_cast<RenderText *>(r)->length();
             if (style->preserveNewline()) {
-                const QChar* text = static_cast<RenderText *>(r)->text();
+                const UChar* text = static_cast<RenderText *>(r)->text();
                 int o = n == startNode ? offset : 0;
                 for (int i = o; i < length; ++i)
                     if (text[i] == '\n')
index 73a1d66..f260354 100644 (file)
@@ -1442,7 +1442,7 @@ String HTMLInputElement::constrainValue(const String& proposedValue, int maxLen)
         StringImpl* s = proposedValue.impl();
         int newLen = numCharactersInGraphemeClusters(s, maxLen);
         for (int i = 0; i < newLen; ++i)
-            if ((*s)[i].unicode() < ' ') {
+            if ((*s)[i] < ' ') {
                 newLen = i;
                 break;
             }
index 523f141..890099a 100644 (file)
@@ -49,6 +49,8 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
+const UChar nonBreakingSpace = 0xa0;
+
 /**
  * @internal
  */
@@ -473,7 +475,7 @@ bool HTMLParser::handleError(Node* n, bool flat, const AtomicString& localName,
                         return false;
                     StringImpl *i = t->string();
                     unsigned int pos = 0;
-                    while (pos < i->length() && ((*i)[pos] == ' ' || (*i)[pos] == QChar(0xa0)))
+                    while (pos < i->length() && ((*i)[pos] == ' ' || (*i)[pos] == nonBreakingSpace))
                         pos++;
                     if (pos == i->length())
                         possiblyMoveStrayContent = false;
index a633f9e..72b1988 100644 (file)
@@ -66,9 +66,6 @@ static const char styleEnd [] =  "</style";
 static const char textareaEnd [] = "</textarea";
 static const char titleEnd [] = "</title";
 
-#define KHTML_ALLOC_QCHAR_VEC( N ) (QChar*) fastMalloc( sizeof(QChar)*( N ) )
-#define KHTML_DELETE_QCHAR_VEC( P ) fastFree((char*)( P ))
-
 // Full support for MS Windows extensions to Latin-1.
 // Technically these extensions should only be activated for pages
 // marked "windows-1252" or "cp1252", but
@@ -84,38 +81,36 @@ static const char titleEnd [] = "</title";
 
 // We only need this for entities. For non-entity text, we handle this in the text encoding.
 
-static const unsigned short windowsLatin1ExtensionArray[32] = {
+static const UChar windowsLatin1ExtensionArray[32] = {
     0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, // 80-87
     0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F, // 88-8F
     0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, // 90-97
     0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178  // 98-9F
 };
 
-static inline QChar fixUpChar(QChar c)
+static inline UChar fixUpChar(UChar c)
 {
-    unsigned short code = c.unicode();
-    if ((code & ~0x1F) != 0x0080)
+    if ((c & ~0x1F) != 0x0080)
         return c;
-    return windowsLatin1ExtensionArray[code - 0x80];
+    return windowsLatin1ExtensionArray[c - 0x80];
 }
 
-inline bool tagMatch(const char *s1, const QChar *s2, unsigned length)
+static inline bool tagMatch(const char* s1, const UChar* s2, unsigned length)
 {
     for (unsigned i = 0; i != length; ++i) {
-        char c1 = s1[i];
-        char uc1 = toupper(c1);
-        QChar c2 = s2[i];
+        unsigned char c1 = s1[i];
+        unsigned char uc1 = toupper(c1);
+        UChar c2 = s2[i];
         if (c1 != c2 && uc1 != c2)
             return false;
     }
     return true;
 }
 
-void Token::addAttribute(Document* doc, const AtomicString& attrName, const AtomicString& v)
+inline void Token::addAttribute(Document* doc, const AtomicString& attrName, const AtomicString& v)
 {
-    Attribute* a = 0;
     if (!attrName.isEmpty() && attrName != "/") {
-        a = new MappedAttribute(attrName, v);
+        Attribute* a = new MappedAttribute(attrName, v);
         if (!attrs)
             attrs = new NamedMappedAttrMap(0);
         attrs->insertAttribute(a);
@@ -166,13 +161,11 @@ void HTMLTokenizer::reset()
       cs->deref(this);
     }
     
-    if (buffer)
-        KHTML_DELETE_QCHAR_VEC(buffer);
+    fastFree(buffer);
     buffer = dest = 0;
     size = 0;
 
-    if (scriptCode)
-        KHTML_DELETE_QCHAR_VEC(scriptCode);
+    fastFree(scriptCode);
     scriptCode = 0;
     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
 
@@ -189,7 +182,7 @@ void HTMLTokenizer::begin()
     m_state.setLoadingExtScript(false);
     reset();
     size = 254;
-    buffer = KHTML_ALLOC_QCHAR_VEC( 255 );
+    buffer = static_cast<UChar*>(fastMalloc(sizeof(UChar) * 254));
     dest = buffer;
     tquote = NoQuote;
     searchCount = 0;
@@ -261,13 +254,13 @@ HTMLTokenizer::State HTMLTokenizer::parseSpecial(SegmentedString &src, State sta
 
     while ( !src.isEmpty() ) {
         checkScriptBuffer();
-        unsigned char ch = src->latin1();
+        UChar ch = *src;
         if (!scriptCodeResync && !brokenComments && !state.inTextArea() && !state.inXmp() && !state.inTitle() && ch == '-' && scriptCodeSize >= 3 && !src.escaped() && scriptCode[scriptCodeSize-3] == '<' && scriptCode[scriptCodeSize-2] == '!' && scriptCode[scriptCodeSize-1] == '-') {
             state.setInComment(true);
             state = parseComment(src, state);
             continue;
         }
-        if ( scriptCodeResync && !tquote && ( ch == '>' ) ) {
+        if (scriptCodeResync && !tquote && ch == '>') {
             ++src;
             scriptCodeSize = scriptCodeResync-1;
             scriptCodeResync = 0;
@@ -302,29 +295,28 @@ HTMLTokenizer::State HTMLTokenizer::parseSpecial(SegmentedString &src, State sta
             return state;
         }
         // possible end of tagname, lets check.
-        if ( !scriptCodeResync && !state.escaped() && !src.escaped() && ( ch == '>' || ch == '/' || ch <= ' ' ) && ch &&
+        if (!scriptCodeResync && !state.escaped() && !src.escaped() && (ch == '>' || ch == '/' || ch <= ' ') && ch &&
              scriptCodeSize >= searchStopperLen &&
              tagMatch( searchStopper, scriptCode+scriptCodeSize-searchStopperLen, searchStopperLen )) {
             scriptCodeResync = scriptCodeSize-searchStopperLen+1;
             tquote = NoQuote;
             continue;
         }
-        if ( scriptCodeResync && !state.escaped() ) {
-            if(ch == '\"')
+        if (scriptCodeResync && !state.escaped()) {
+            if (ch == '\"')
                 tquote = (tquote == NoQuote) ? DoubleQuote : ((tquote == SingleQuote) ? SingleQuote : NoQuote);
-            else if(ch == '\'')
+            else if (ch == '\'')
                 tquote = (tquote == NoQuote) ? SingleQuote : (tquote == DoubleQuote) ? DoubleQuote : NoQuote;
             else if (tquote != NoQuote && (ch == '\r' || ch == '\n'))
                 tquote = NoQuote;
         }
         state.setEscaped(!state.escaped() && ch == '\\');
         if (!scriptCodeResync && (state.inTextArea() || state.inTitle()) && !src.escaped() && ch == '&') {
-            QChar *scriptCodeDest = scriptCode+scriptCodeSize;
+            UChar* scriptCodeDest = scriptCode+scriptCodeSize;
             ++src;
             state = parseEntity(src, scriptCodeDest, state, m_cBufferPos, true, false);
             scriptCodeSize = scriptCodeDest-scriptCode;
-        }
-        else {
+        } else {
             scriptCode[scriptCodeSize++] = *src;
             ++src;
         }
@@ -370,7 +362,7 @@ HTMLTokenizer::State HTMLTokenizer::scriptHandler(State state)
         doScriptExec = true;
     }
     state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
-    DeprecatedString exScript( buffer, dest-buffer );
+    DeprecatedString exScript(reinterpret_cast<QChar*>(buffer), dest - buffer);
     processToken();
     currToken.tagName = scriptTag.localName();
     currToken.beginTag = false;
@@ -506,12 +498,8 @@ HTMLTokenizer::State HTMLTokenizer::parseComment(SegmentedString &src, State sta
     checkScriptBuffer(src.length());
     while ( !src.isEmpty() ) {
         scriptCode[ scriptCodeSize++ ] = *src;
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-        qDebug("comment is now: *%s*",
-               QConstString((QChar*)src.operator->(), min(16U, src.length())).string().latin1());
-#endif
 
-        if (src->unicode() == '>') {
+        if (*src == '>') {
             bool handleBrokenComments = brokenComments && !(state.inScript() || state.inStyle());
             int endCharsCount = 1; // start off with one for the '>' character
             if (scriptCodeSize > 2 && scriptCode[scriptCodeSize-3] == '-' && scriptCode[scriptCodeSize-2] == '-') {
@@ -555,7 +543,7 @@ HTMLTokenizer::State HTMLTokenizer::parseServer(SegmentedString& src, State stat
     checkScriptBuffer(src.length());
     while (!src.isEmpty()) {
         scriptCode[scriptCodeSize++] = *src;
-        if (src->unicode() == '>' &&
+        if (*src == '>' &&
             scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
             ++src;
             state.setInServer(false);
@@ -569,21 +557,17 @@ HTMLTokenizer::State HTMLTokenizer::parseServer(SegmentedString& src, State stat
 
 HTMLTokenizer::State HTMLTokenizer::parseProcessingInstruction(SegmentedString &src, State state)
 {
-    char oldchar = 0;
-    while ( !src.isEmpty() )
-    {
-        unsigned char chbegin = src->latin1();
-        if(chbegin == '\'') {
+    UChar oldchar = 0;
+    while (!src.isEmpty()) {
+        UChar chbegin = *src;
+        if (chbegin == '\'')
             tquote = tquote == SingleQuote ? NoQuote : SingleQuote;
-        }
-        else if(chbegin == '\"') {
+        else if (chbegin == '\"')
             tquote = tquote == DoubleQuote ? NoQuote : DoubleQuote;
-        }
         // Look for '?>'
-        // some crappy sites omit the "?" before it, so
+        // Some crappy sites omit the "?" before it, so
         // we look for an unquoted '>' instead. (IE compatible)
-        else if ( chbegin == '>' && ( !tquote || oldchar == '?' ) )
-        {
+        else if (chbegin == '>' && (!tquote || oldchar == '?')) {
             // We got a '?>' sequence
             state.setInProcessingInstruction(false);
             ++src;
@@ -600,7 +584,7 @@ HTMLTokenizer::State HTMLTokenizer::parseProcessingInstruction(SegmentedString &
 HTMLTokenizer::State HTMLTokenizer::parseText(SegmentedString &src, State state)
 {
     while (!src.isEmpty()) {
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
 
         if (state.skipLF()) {
             state.setSkipLF(false);
@@ -625,7 +609,7 @@ HTMLTokenizer::State HTMLTokenizer::parseText(SegmentedString &src, State state)
 }
 
 
-HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&dest, State state, unsigned &cBufferPos, bool start, bool parsingTag)
+HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, UChar*& dest, State state, unsigned &cBufferPos, bool start, bool parsingTag)
 {
     if (start)
     {
@@ -636,7 +620,7 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
 
     while(!src.isEmpty())
     {
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
         switch(state.entityState()) {
         case NoEntity:
             ASSERT(state.entityState() != NoEntity);
@@ -654,30 +638,30 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
             break;
 
         case NumericSearch:
-            if(cc == 'x' || cc == 'X') {
+            if (cc == 'x' || cc == 'X') {
                 cBuffer[cBufferPos++] = cc;
                 ++src;
                 state.setEntityState(Hexadecimal);
-            }
-            else if(cc >= '0' && cc <= '9')
+            } else if (cc >= '0' && cc <= '9')
                 state.setEntityState(Decimal);
             else
                 state.setEntityState(SearchSemicolon);
-
             break;
 
-        case Hexadecimal:
-        {
-            int ll = min(src.length(), 10-cBufferPos);
-            while(ll--) {
-                QChar csrc(src->lower());
-                cc = csrc.unicode();
-
-                if (!((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f'))) {
+        case Hexadecimal: {
+            int ll = min(src.length(), 10 - cBufferPos);
+            while (ll--) {
+                cc = *src;
+                if (!((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f') || (cc >= 'A' && cc <= 'F'))) {
                     state.setEntityState(SearchSemicolon);
                     break;
                 }
-                EntityUnicodeValue = EntityUnicodeValue*16 + (cc - ( cc < 'a' ? '0' : 'a' - 10));
+                int digit;
+                if (cc < 'A')
+                    digit = cc - '0';
+                else
+                    digit = (cc - 'A' + 10) & 0xF; // handle both upper and lower case without a branch
+                EntityUnicodeValue = EntityUnicodeValue * 16 + digit;
                 cBuffer[cBufferPos++] = cc;
                 ++src;
             }
@@ -689,7 +673,7 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
         {
             int ll = min(src.length(), 9-cBufferPos);
             while(ll--) {
-                cc = src->unicode();
+                cc = *src;
 
                 if (!(cc >= '0' && cc <= '9')) {
                     state.setEntityState(SearchSemicolon);
@@ -708,8 +692,7 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
         {
             int ll = min(src.length(), 9-cBufferPos);
             while(ll--) {
-                QChar csrc = *src;
-                cc = csrc.unicode();
+                cc = *src;
 
                 if (!((cc >= 'a' && cc <= 'z') || (cc >= '0' && cc <= '9') || (cc >= 'A' && cc <= 'Z'))) {
                     state.setEntityState(SearchSemicolon);
@@ -737,21 +720,17 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
         }
         case SearchSemicolon:
             // Don't allow values that are more than 21 bits.
-            if (EntityUnicodeValue > 0 && EntityUnicodeValue <= 0x1FFFFF) {
-            
+            if (EntityUnicodeValue > 0 && EntityUnicodeValue <= 0x10FFFF) {
                 if (*src == ';')
                     ++src;
-
                 if (EntityUnicodeValue <= 0xFFFF) {
                     checkBuffer();
                     src.push(fixUpChar(EntityUnicodeValue));
                 } else {
                     // Convert to UTF-16, using surrogate code points.
-                    QChar c1(0xD800 | (((EntityUnicodeValue >> 16) - 1) << 6) | ((EntityUnicodeValue >> 10) & 0x3F));
-                    QChar c2(0xDC00 | (EntityUnicodeValue & 0x3FF));
                     checkBuffer(2);
-                    src.push(c1);
-                    src.push(c2);
+                    src.push(U16_LEAD(EntityUnicodeValue));
+                    src.push(U16_TRAIL(EntityUnicodeValue));
                 }
             } else {
                 checkBuffer(10);
@@ -779,13 +758,6 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
     while (!src.isEmpty())
     {
         checkBuffer();
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-        unsigned l = 0;
-        while(l < src.length() && (*(src.operator->()+l)).latin1() != '>')
-            l++;
-        qDebug("src is now: *%s*, tquote: %d",
-               QConstString((QChar*)src.operator->(), l).deprecatedString().latin1(), tquote);
-#endif
         switch(state.tagState()) {
         case NoTag:
         {
@@ -821,7 +793,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
                           ++src;
                           if (!src.isEmpty())
                               // cuts off high bits, which is okay
-                              cBuffer[cBufferPos++] = src->unicode();
+                              cBuffer[cBufferPos++] = *src;
                         }
                         else
                           state = parseComment(src, state);
@@ -830,7 +802,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
                         return state; // Finished parsing tag!
                     }
                     // cuts off high bits, which is okay
-                    cBuffer[cBufferPos++] = src->unicode();
+                    cBuffer[cBufferPos++] = *src;
                     ++src;
                     break;
                 }
@@ -841,7 +813,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
             bool finish = false;
             unsigned int ll = min(src.length(), CBUFLEN-cBufferPos);
             while(ll--) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar <= ' ' || curchar == '>' ) {
                     finish = true;
                     break;
@@ -893,7 +865,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
             qDebug("SearchAttribute");
 #endif
             while(!src.isEmpty()) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 // In this mode just ignore any quotes we encounter and treat them like spaces.
                 if (curchar > ' ' && curchar != '\'' && curchar != '"') {
                     if (curchar == '<' || curchar == '>')
@@ -914,7 +886,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
 #endif
             int ll = min(src.length(), CBUFLEN-cBufferPos);
             while(ll--) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if (curchar <= '>' && (curchar >= '=' || curchar <= ' ')) {
                     cBuffer[cBufferPos] = '\0';
                     attrName = AtomicString(cBuffer);
@@ -952,7 +924,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
             qDebug("SearchEqual");
 #endif
             while(!src.isEmpty()) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 // In this mode just ignore any quotes we encounter and treat them like spaces.
                 if (curchar > ' ' && curchar != '\'' && curchar != '"') {
                     if(curchar == '=') {
@@ -974,7 +946,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
             break;
         case SearchValue:
             while(!src.isEmpty()) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar > ' ') {
                     if(( curchar == '\'' || curchar == '\"' )) {
                         tquote = curchar == '\"' ? DoubleQuote : SingleQuote;
@@ -995,7 +967,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
             while(!src.isEmpty()) {
                 checkBuffer();
 
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if (curchar == '>' && attrName.isEmpty()) {
                     // Handle a case like <img '>.  Just go ahead and be willing
                     // to close the whole tag.  Don't consume the character and
@@ -1051,7 +1023,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
 #endif
             while(!src.isEmpty()) {
                 checkBuffer();
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar <= '>' && !src.escaped()) {
                     // parse Entities
                     if ( curchar == '&' )
@@ -1340,7 +1312,7 @@ bool HTMLTokenizer::write(const SegmentedString &str, bool appendData)
         // do we need to enlarge the buffer?
         checkBuffer();
 
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
 
         bool wasSkipLF = state.skipLF();
         if (wasSkipLF)
@@ -1505,12 +1477,11 @@ void HTMLTokenizer::end()
         if (!m_state.hasTagState())
             processToken();
 
-        if (scriptCode)
-            KHTML_DELETE_QCHAR_VEC(scriptCode);
+        fastFree(scriptCode);
         scriptCode = 0;
         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
 
-        KHTML_DELETE_QCHAR_VEC(buffer);
+        fastFree(buffer);
         buffer = 0;
     }
 
@@ -1532,15 +1503,15 @@ void HTMLTokenizer::finish()
         int pos;
         DeprecatedString food;
         if (m_state.inScript() || m_state.inStyle())
-            food.setUnicode(scriptCode, scriptCodeSize);
+            food.setUnicode(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize);
         else if (m_state.inServer()) {
             food = "<";
-            food += DeprecatedString(scriptCode, scriptCodeSize);
+            food += DeprecatedString(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize);
         } else {
-            pos = QConstString(scriptCode, scriptCodeSize).string().find('>');
-            food.setUnicode(scriptCode+pos+1, scriptCodeSize-pos-1); // deep copy
+            pos = QConstString(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize).string().find('>');
+            food.setUnicode(reinterpret_cast<QChar*>(scriptCode) + pos + 1, scriptCodeSize - pos - 1); // deep copy
         }
-        KHTML_DELETE_QCHAR_VEC(scriptCode);
+        fastFree(scriptCode);
         scriptCode = 0;
         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
         m_state.setInComment(false);
@@ -1626,22 +1597,21 @@ HTMLTokenizer::~HTMLTokenizer()
 
 void HTMLTokenizer::enlargeBuffer(int len)
 {
-    int newsize = max(size*2, size+len);
-    int oldoffs = (dest - buffer);
-
-    buffer = (QChar*)fastRealloc(buffer, newsize*sizeof(QChar));
-    dest = buffer + oldoffs;
-    size = newsize;
+    int newSize = max(size * 2, size + len);
+    int oldOffset = dest - buffer;
+    buffer = static_cast<UChar*>(fastRealloc(buffer, newSize * sizeof(UChar)));
+    dest = buffer + oldOffset;
+    size = newSize;
 }
 
 void HTMLTokenizer::enlargeScriptBuffer(int len)
 {
-    int newsize = max(scriptCodeMaxSize*2, scriptCodeMaxSize+len);
-    scriptCode = (QChar*)fastRealloc(scriptCode, newsize*sizeof(QChar));
-    scriptCodeMaxSize = newsize;
+    int newSize = max(scriptCodeMaxSize * 2, scriptCodeMaxSize + len);
+    scriptCode = static_cast<UChar*>(fastRealloc(scriptCode, newSize * sizeof(UChar)));
+    scriptCodeMaxSize = newSize;
 }
 
-void HTMLTokenizer::notifyFinished(CachedObject */*finishedObj*/)
+void HTMLTokenizer::notifyFinished(CachedObject*)
 {
 #if INSTRUMENT_LAYOUT_SCHEDULING
     if (!parser->doc()->ownerElement())
@@ -1728,7 +1698,7 @@ void parseHTMLDocumentFragment(const String &source, DocumentFragment *fragment)
     ASSERT(!tok.processingData());      // make sure we're done (see 3963151)
 }
 
-unsigned short decodeNamedEntity(const char* name)
+UChar decodeNamedEntity(const char* name)
 {
     const Entity* e = findEntity(name, strlen(name));
     return e ? e->code : 0;
index e33139a..70c3e94 100644 (file)
@@ -82,7 +82,7 @@ public:
     HTMLTokenizer(DocumentFragment*);
     virtual ~HTMLTokenizer();
 
-    virtual bool write(const SegmentedString &str, bool appendData);
+    virtual bool write(const SegmentedString&, bool appendData);
     virtual void finish();
     virtual void setForceSynchronous(bool force);
     virtual bool isWaitingForScripts() const;
@@ -106,11 +106,11 @@ private:
     State parseText(SegmentedString&, State);
     State parseSpecial(SegmentedString&, State);
     State parseTag(SegmentedString&, State);
-    State parseEntity(SegmentedString &, QChar*& dest, State, unsigned& _cBufferPos, bool start, bool parsingTag);
+    State parseEntity(SegmentedString&, UChar*& dest, State, unsigned& _cBufferPos, bool start, bool parsingTag);
     State parseProcessingInstruction(SegmentedString&, State);
     State scriptHandler(State);
     State scriptExecution(const DeprecatedString& script, State state, DeprecatedString scriptURL = DeprecatedString(), int baseLine = 0);
-    void setSrc(const SegmentedString &source);
+    void setSrc(const SegmentedString&);
 
     // check if we have enough space in the buffer.
     // if not enlarge it
@@ -128,7 +128,7 @@ private:
     void enlargeBuffer(int len);
     void enlargeScriptBuffer(int len);
 
-    bool continueProcessing(int& processedCount, double startTime, State &state);
+    bool continueProcessing(int& processedCount, double startTime, State&);
     void timerFired(Timer<HTMLTokenizer>*);
     void allDataProcessed();
 
@@ -137,8 +137,8 @@ private:
 
     // Internal buffers
     ///////////////////
-    QChar *buffer;
-    QChar *dest;
+    UChar* buffer;
+    UChar* dest;
 
     Token currToken;
 
@@ -148,12 +148,7 @@ private:
     // Tokenizer flags
     //////////////////
     // are we in quotes within a html tag
-    enum
-    {
-        NoQuote = 0,
-        SingleQuote,
-        DoubleQuote
-    } tquote;
+    enum { NoQuote, SingleQuote, DoubleQuote } tquote;
 
     // Are we in a &... character entity description?
     enum EntityState {
@@ -273,7 +268,7 @@ private:
     AtomicString attrName;
     
     // Used to store the code of a srcipting sequence
-    QChar *scriptCode;
+    UChar* scriptCode;
     // Size of the script sequenze stored in @ref #scriptCode
     int scriptCodeSize;
     // Maximal size that can be stored in @ref #scriptCode
@@ -282,11 +277,11 @@ private:
     int scriptCodeResync;
 
     // Stores characters if we are scanning for a string like "</script>"
-    QChar searchBuffer[ 10 ];
+    UChar searchBuffer[10];
     // Counts where we are in the string we are scanning for
     int searchCount;
     // The string we are searching for
-    const QChar *searchFor;
+    const UChar* searchFor;
     // the stopper string
     const char* searchStopper;
     // the stopper len
@@ -339,7 +334,7 @@ private:
 
 void parseHTMLDocumentFragment(const String&, DocumentFragment*);
 
-unsigned short decodeNamedEntity(const char*);
+UChar decodeNamedEntity(const char*);
 
 }
 
index e9c6eaf..1e5a46e 100644 (file)
@@ -406,32 +406,32 @@ HTMLFontElement::~HTMLFontElement()
 // Allows leading spaces.
 // Allows trailing nonnumeric characters.
 // Returns 10 for any size greater than 9.
-static bool parseFontSizeNumber(const String &s, int &size)
+static bool parseFontSizeNumber(const String& s, int& size)
 {
     unsigned pos = 0;
     
     // Skip leading spaces.
-    while (pos < s.length() && s[pos].isSpace())
+    while (QChar(s[pos]).isSpace())
         ++pos;
     
     // Skip a plus or minus.
     bool sawPlus = false;
     bool sawMinus = false;
-    if (pos < s.length() && s[pos] == '+') {
+    if (s[pos] == '+') {
         ++pos;
         sawPlus = true;
-    } else if (pos < s.length() && s[pos] == '-') {
+    } else if (s[pos] == '-') {
         ++pos;
         sawMinus = true;
     }
     
     // Parse a single digit.
-    if (pos >= s.length() || !s[pos].isNumber())
+    if (!u_isdigit(s[pos]))
         return false;
-    int num = s[pos++].digitValue();
+    int num = u_charDigitValue(s[pos++]);
     
     // Check for an additional digit.
-    if (pos < s.length() && s[pos].isNumber())
+    if (u_isdigit(s[pos]))
         num = 10;
     
     if (sawPlus) {
index edab95b..9db1d45 100644 (file)
 #import "config.h"
 #import "KWQLoader.h"
 
+#import "BlockExceptions.h"
 #import "Cache.h"
 #import "CachedImage.h"
 #import "DocLoader.h"
 #import "FoundationExtras.h"
-#import "BlockExceptions.h"
+#import "FrameMac.h"
 #import "KWQFormData.h"
-#import "TransferJob.h"
-#import "Logging.h"
 #import "KWQResourceLoader.h"
-#import "FrameMac.h"
+#import "Logging.h"
 #import "Request.h"
+#import "TransferJob.h"
 #import "WebCoreFrameBridge.h"
 #import "loader.h"
-#import "loader.h"
-
 #import <Foundation/NSURLResponse.h>
 
 using namespace WebCore;
@@ -215,37 +213,18 @@ void KWQCheckCacheObjectStatus(DocLoader *loader, CachedObject *cachedObject)
     }
 }
 
-#define LOCAL_STRING_BUFFER_SIZE 1024
-
-bool KWQIsResponseURLEqualToURL(NSURLResponse *response, const WebCore::String &m_url)
+bool KWQIsResponseURLEqualToURL(NSURLResponse *response, const WebCore::String& m_url)
 {
-    unichar _buffer[LOCAL_STRING_BUFFER_SIZE];
-    unichar *urlStringCharacters;
-    
     NSURL *responseURL = [(NSURLResponse *)response URL];
     NSString *urlString = [responseURL absoluteString];
 
-    if (m_url.length() != [urlString length])
+    size_t length = m_url.length();
+    if (length != [urlString length])
         return false;
-        
-    // Nasty hack to directly compare strings buffers of NSString
-    // and String.  We do this for speed.
-    if ([urlString length] > LOCAL_STRING_BUFFER_SIZE) {
-        urlStringCharacters = (unichar *)fastMalloc(sizeof(unichar)*[urlString length]);
-    }
-    else {
-        urlStringCharacters = _buffer;
-    }
-    [urlString getCharacters:urlStringCharacters];
-    
-    bool ret = false;
-    if(!memcmp(urlStringCharacters, m_url.unicode(), m_url.length()*sizeof(QChar)))
-        ret = true;
-    
-    if (urlStringCharacters != _buffer)
-        fastFree(urlStringCharacters);
-        
-    return ret;
+
+    Vector<UChar, 1024> buffer(length);
+    [urlString getCharacters:buffer.data()];    
+    return !memcmp(buffer.data(), m_url.characters(), length * sizeof(UChar));
 }
 
 DeprecatedString KWQResponseURL(NSURLResponse *response)
index e07bb11..141e057 100644 (file)
@@ -26,6 +26,7 @@
 #include "config.h"
 #include "KWQTextStream.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "Logging.h"
 
index 1b5d52d..b05728a 100644 (file)
@@ -1268,7 +1268,7 @@ static WebCoreAXObject *AXLinkElementForNode (Node *node)
     return anchor->renderer()->document()->getAccObjectCache()->get(anchor->renderer());
 }
 
-static void AXAttributedStringAppendText (NSMutableAttributedString *attrString, Node *nodeImpl, const QChar *chars, int length)
+static void AXAttributedStringAppendText(NSMutableAttributedString* attrString, Node* nodeImpl, const UChar* chars, int length)
 {
     // skip invisible text
     if (!nodeImpl->renderer())
@@ -1278,7 +1278,7 @@ static void AXAttributedStringAppendText (NSMutableAttributedString *attrString,
     NSRange attrStringRange = NSMakeRange([attrString length], length);
     
     // append the string from this node
-    [[attrString mutableString] appendString:[NSString stringWithCharacters:(const UniChar*)chars length:length]];
+    [[attrString mutableString] appendString:[NSString stringWithCharacters:chars length:length]];
 
     // add new attributes and remove irrelevant inherited ones
     // NOTE: color attributes are handled specially because -[NSMutableAttributedString addAttribute: value: range:] does not merge
@@ -1350,9 +1350,9 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
         
         // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX)
         if (it.length() != 0) {
-            AXAttributedStringAppendText (attrString, nodeImpl, it.characters(), it.length());
+            AXAttributedStringAppendText(attrString, nodeImpl, it.characters(), it.length());
         } else {
-            AXAttributedStringAppendReplaced (attrString, nodeImpl->childNode(it.range()->startOffset(exception)));
+            AXAttributedStringAppendReplaced(attrString, nodeImpl->childNode(it.range()->startOffset(exception)));
         }
         
         it.advance();
index 156de8b..8b033c8 100644 (file)
@@ -227,14 +227,6 @@ CachedCSSStyleSheet *Cache::requestStyleSheet(DocLoader* dl, const String& url,
     return static_cast<CachedCSSStyleSheet *>(o);
 }
 
-void Cache::preloadStyleSheet(const DeprecatedString& url, const DeprecatedString& stylesheet_data)
-{
-    CachedObject *o = cache->get(String(url).impl());
-    if (o)
-        remove(o);
-    cache->set(String(url).impl(), new CachedCSSStyleSheet(url, stylesheet_data));
-}
-
 CachedScript *Cache::requestScript(DocLoader* dl, const String& url, bool reload, time_t expireDate, const DeprecatedString& charset)
 {
     // this brings the _url to a standard form...
@@ -286,14 +278,6 @@ CachedScript *Cache::requestScript(DocLoader* dl, const String& url, bool reload
     return static_cast<CachedScript *>(o);
 }
 
-void Cache::preloadScript(const DeprecatedString& url, const DeprecatedString& script_data)
-{
-    CachedObject *o = cache->get(String(url).impl());
-    if (o)
-        remove(o);
-    cache->set(String(url).impl(), new CachedScript(url, script_data));
-}
-
 #ifdef KHTML_XSLT
 CachedXSLStyleSheet* Cache::requestXSLStyleSheet(DocLoader* dl, const String& url, bool reload, time_t expireDate)
 {
index f314589..fb0e0ef 100644 (file)
@@ -48,63 +48,39 @@ namespace WebCore  {
     
     /**
      * Provides a cache/loader for objects needed for displaying the html page.
-     * At the moment these are stylesheets, scripts and images
      */
     class Cache {
         friend class DocLoader;
     public:
         /**
-         * init the cache in case it's not already. This needs to get called once
-         * before using it.
+         * Initialize the cache in case it's not already.
+         * This needs to get called once before using it.
          */
         static void init();
         
         /**
-         * Ask the cache for some url. Will return a cachedObject, and
-         * load the requested data in case it's not cahced
-         * if the DocLoader is zero, the url must be full-qualified.
-         * Otherwise, it is automatically base-url expanded
+         * Ask the cache for some URL.
+         * If the DocLoader is zero, the URL must be fully-qualified. Otherwise, it is automatically base-URL expanded
          */
         static CachedImage* requestImage(DocLoader*, const String& URL, bool reload = false, time_t expireDate = 0);
-        static CachedImage* requestImage(DocLoader*, const KURL& url, bool reload = false, time_t expireDate = 0);
-
-        /**
-         * Ask the cache for some url. Will return a cachedObject, and
-         * load the requested data in case it's not cached
-         */
-        static CachedCSSStyleSheet* requestStyleSheet(DocLoader*, const String& URL, bool reload = false, time_t expireDate = 0, const DeprecatedString& charset = DeprecatedString::null);
-
-        /**
-         * Pre-loads a stylesheet into the cache.
-         */
-        static void preloadStyleSheet(const DeprecatedString &url, const DeprecatedString& stylesheetData);
-
-        /**
-         * Ask the cache for some url. Will return a cachedObject, and
-         * load the requested data in case it's not cahced
-         */
-        static CachedScript* requestScript(DocLoader*, const String& URL, bool reload = false, time_t expireDate = 0, const DeprecatedString& charset = DeprecatedString::null);
-
-        /**
-         * Pre-loads a script into the cache.
-         */
-        static void preloadScript(const DeprecatedString &url, const DeprecatedString& scriptData);
+        static CachedImage* requestImage(DocLoader*, const KURL& URL, bool reload, time_t expireDate);
+        static CachedCSSStyleSheet* requestStyleSheet(DocLoader*, const String& URL, bool reload, time_t expireDate, const DeprecatedString& charset);
+        static CachedScript* requestScript(DocLoader*, const String& URL, bool reload, time_t expireDate, const DeprecatedString& charset);
 
 #ifdef KHTML_XSLT
-        // Ask the cache for an XSL stylesheet.
-        static CachedXSLStyleSheet* requestXSLStyleSheet(DocLoader*, const String& URL, bool reload = false, time_t expireDate = 0);
+        static CachedXSLStyleSheet* requestXSLStyleSheet(DocLoader*, const String& URL, bool reload, time_t expireDate);
 #endif
 
 #ifndef KHTML_NO_XBL
-        // Ask the cache for an XBL document.
-        static CachedXBLDocument* requestXBLDocument(DocLoader*, const String& URL, bool reload = false, time_t expireDate = 0);
+        static CachedXBLDocument* requestXBLDocument(DocLoader*, const String& URL, bool reload, time_t expireDate);
 #endif
 
         /**
-         * Sets the size of the cache. This will only hod approximately, since the size some
-         * cached objects (like stylesheets) take up in memory is not exaclty known.
+         * Sets the size of the cache. This will only hold approximately, since the size some
+         * cached objects (like stylesheets) take up in memory is not exactly known.
          */
         static void setSize(int bytes);
+
         /**
          * returns the size of the cache
          */
@@ -125,8 +101,8 @@ namespace WebCore  {
 
         /**
          * clears the cache
-         * Warning: call this only at the end of your program, to clean
-         * up memory (useful for finding memory holes)
+         * Warning: call this only at the end of your program, to clean up memory
+         * (useful for finding memory leaks).
          */
         static void clear();
 
index 2f45ad3..b1dc8c6 100644 (file)
@@ -27,6 +27,7 @@
 #ifndef KHTML_CachedObject_h
 #define KHTML_CachedObject_h
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "KWQKIOGlobal.h"
 #include <wtf/HashSet.h>
index 33ec6c5..0c46f4b 100644 (file)
 #endif
 
 using namespace std;
-using namespace KJS;
+
+using KJS::JSLock;
+using KJS::JSValue;
+using KJS::Location;
+using KJS::PausedTimeouts;
+using KJS::SavedProperties;
+using KJS::SavedBuiltins;
+using KJS::UString;
+using KJS::Window;
 
 namespace WebCore {
 
@@ -96,7 +104,7 @@ class UserStyleSheetLoader : public CachedObjectClient {
 public:
     UserStyleSheetLoader(Frame* frame, const String& url, DocLoader* dl)
         : m_frame(frame)
-        , m_cachedSheet(Cache::requestStyleSheet(dl, url))
+        , m_cachedSheet(Cache::requestStyleSheet(dl, url, false, 0, ""))
     {
         m_cachedSheet->ref(this);
     }
@@ -3254,7 +3262,7 @@ void Frame::setWindowHasFocus(bool flag)
         doc->dispatchWindowEvent(flag ? focusEvent : blurEvent, false, false);
 }
 
-QChar Frame::backslashAsCurrencySymbol() const
+UChar Frame::backslashAsCurrencySymbol() const
 {
     Document *doc = document();
     if (!doc)
index 853cabd..496c4f4 100644 (file)
@@ -712,7 +712,7 @@ private:
   void setWindowHasFocus(bool flag);
   // Convenience, to avoid repeating the code to dig down to get this.
 
-  QChar backslashAsCurrencySymbol() const;
+  UChar backslashAsCurrencySymbol() const;
 
   DeprecatedValueList<MarkedTextUnderline> markedTextUnderlines() const;  
   bool markedTextUsesUnderlines() const;
index fe919bf..2e3b986 100644 (file)
 #include "config.h"
 
 #if AVOID_STATIC_CONSTRUCTORS
-#define KHTML_ATOMICSTRING_HIDE_GLOBALS 1
+#define ATOMICSTRING_HIDE_GLOBALS 1
 #endif
 
 #include "AtomicString.h"
 
+#include "DeprecatedString.h"
 #include "StaticConstructors.h"
 #include "StringHash.h"
 #include <kjs/identifier.h>
 #include <wtf/HashSet.h>
 
-using namespace KJS;
+using KJS::Identifier;
+using KJS::UString;
 
 namespace WebCore {
-   
+
 static HashSet<StringImpl*>* stringTable;
 
 struct CStringTranslator 
@@ -49,7 +51,7 @@ struct CStringTranslator
     static bool equal(StringImpl* r, const char* s)
     {
         int length = r->length();
-        const QChar* d = r->unicode();
+        const UChar* d = r->characters();
         for (int i = 0; i != length; ++i)
             if (d[i] != s[i])
                 return false;
@@ -68,9 +70,9 @@ struct CStringTranslator
 bool operator==(const AtomicString& a, const char* b)
 { 
     StringImpl* impl = a.impl();
-    if ((!impl || !impl->unicode()) && !b)
+    if ((!impl || !impl->characters()) && !b)
         return true;
-    if ((!impl || !impl->unicode()) || !b)
+    if ((!impl || !impl->characters()) || !b)
         return false;
     return CStringTranslator::equal(impl, b); 
 }
@@ -86,25 +88,25 @@ StringImpl* AtomicString::add(const char* c)
     return *stringTable->add<const char*, CStringTranslator>(c).first;
 }
 
-struct QCharBuffer {
-    const QChar* s;
+struct UCharBuffer {
+    const UChar* s;
     unsigned length;
 };
 
-struct QCharBufferTranslator {
-    static unsigned hash(const QCharBuffer& buf)
+struct UCharBufferTranslator {
+    static unsigned hash(const UCharBuffer& buf)
     {
         return StringImpl::computeHash(buf.s, buf.length);
     }
 
-    static bool equal(StringImpl* const& str, const QCharBuffer& buf)
+    static bool equal(StringImpl* const& str, const UCharBuffer& buf)
     {
         unsigned strLength = str->length();
         unsigned bufLength = buf.length;
         if (strLength != bufLength)
             return false;
         
-        const uint32_t* strChars = reinterpret_cast<const uint32_t*>(str->unicode());
+        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;
@@ -120,7 +122,7 @@ struct QCharBufferTranslator {
         return true;
     }
 
-    static void translate(StringImpl*& location, const QCharBuffer& buf, unsigned hash)
+    static void translate(StringImpl*& location, const UCharBuffer& buf, unsigned hash)
     {
         StringImpl *r = new StringImpl(buf.s, buf.length);
         r->m_hash = hash;
@@ -130,7 +132,7 @@ struct QCharBufferTranslator {
     }
 };
 
-StringImpl* AtomicString::add(const QChar* s, int length)
+StringImpl* AtomicString::add(const UChar* s, int length)
 {
     if (!s)
         return 0;
@@ -138,8 +140,8 @@ StringImpl* AtomicString::add(const QChar* s, int length)
     if (length == 0)
         return StringImpl::empty();
     
-    QCharBuffer buf = {s, length}; 
-    return *stringTable->add<QCharBuffer, QCharBufferTranslator>(buf).first;
+    UCharBuffer buf = {s, length}; 
+    return *stringTable->add<UCharBuffer, UCharBufferTranslator>(buf).first;
 }
 
 StringImpl* AtomicString::add(StringImpl* r)
@@ -163,22 +165,32 @@ void AtomicString::remove(StringImpl* r)
 
 StringImpl* AtomicString::add(const KJS::Identifier& str)
 {
-    return add(reinterpret_cast<const QChar*>(str.data()), str.size());
+    return add(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 StringImpl* AtomicString::add(const KJS::UString& str)
 {
-    return add(reinterpret_cast<const QChar*>(str.data()), str.size());
+    return add(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 AtomicString::operator Identifier() const
 {
-    return domString();
+    return m_string;
 }
 
 AtomicString::operator UString() const
 {
-    return domString();
+    return m_string;
+}
+
+AtomicString::AtomicString(const DeprecatedString& s)
+    : m_string(add(reinterpret_cast<const UChar*>(s.unicode()), s.length()))
+{
+}
+
+DeprecatedString AtomicString::deprecatedString() const
+{
+    return m_string.deprecatedString();
 }
 
 DEFINE_GLOBAL(AtomicString, nullAtom)
index dea12b3..de3a8ab 100644 (file)
@@ -33,36 +33,32 @@ public:
     static void init();
     
     AtomicString() { }
-    AtomicString(QChar c) : m_string(add(&c, 1)) { }
     AtomicString(const char* s) : m_string(add(s)) { }
-    AtomicString(const QChar* s, int length) : m_string(add(s, length)) { }
-    AtomicString(const unsigned short* s, int length) : m_string(add((QChar*)s, length)) { }
-    AtomicString(const DeprecatedString& s) : m_string(add(s.unicode(), s.length())) { }
+    AtomicString(const UChar* s, int length) : m_string(add(s, length)) { }
     AtomicString(const KJS::UString& s) : m_string(add(s)) { }
     AtomicString(const KJS::Identifier& s) : m_string(add(s)) { }
     AtomicString(StringImpl* imp) : m_string(add(imp)) { }
     AtomicString(AtomicStringImpl* imp) : m_string(imp) { }
     AtomicString(const String& s) : m_string(add(s.impl())) { }
-    
+
     operator const String&() const { return m_string; }
     const String& domString() const { return m_string; };
-    DeprecatedString deprecatedString() const { return m_string.deprecatedString(); };
-    
+
     operator KJS::Identifier() const;
     operator KJS::UString() const;
 
     AtomicStringImpl* impl() const { return static_cast<AtomicStringImpl *>(m_string.impl()); }
     
-    const QChar* unicode() const { return m_string.unicode(); }
+    const UChar* characters() const { return m_string.characters(); }
     unsigned length() const { return m_string.length(); }
     
-    const QChar& operator [](unsigned int i) const { return m_string[i]; }
+    UChar operator[](unsigned int i) const { return m_string[i]; }
     
-    bool contains(QChar c) const { return m_string.contains(c); }
+    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); }
 
-    int find(QChar c, int start = 0) const { return m_string.find(c, start); }
+    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); }
     
@@ -86,11 +82,14 @@ public:
     operator NSString*() const { return m_string; }
 #endif
 
+    AtomicString(const DeprecatedString&);
+    DeprecatedString deprecatedString() const;
+
 private:
     String m_string;
     
     static StringImpl* add(const char*);
-    static StringImpl* add(const QChar*, int length);
+    static StringImpl* add(const UChar*, int length);
     static StringImpl* add(StringImpl*);
     static StringImpl* add(const KJS::UString&);
     static StringImpl* add(const KJS::Identifier&);
@@ -115,7 +114,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.
-#if !KHTML_ATOMICSTRING_HIDE_GLOBALS
+#if !ATOMICSTRING_HIDE_GLOBALS
     extern const AtomicString nullAtom;
     extern const AtomicString emptyAtom;
     extern const AtomicString textAtom;
index 2d7b7ba..8312f41 100644 (file)
@@ -26,6 +26,7 @@
 #include "config.h"
 #include "Color.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include <wtf/Assertions.h>
 
index f51301f..309fe2a 100644 (file)
@@ -50,12 +50,6 @@ namespace KJS {
 
 class QChar {
 public:
-
-    enum Direction {
-        DirL = 0, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
-        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
-    };
-    
     QChar();
     QChar(char);
     QChar(unsigned char);
@@ -67,15 +61,8 @@ public:
     unsigned short unicode() const;
     char latin1() const;
     bool isSpace() const;
-    bool isDigit() const;
-    bool isLetter() const;
-    bool isNumber() const;
-    bool isLetterOrNumber() const;
-    bool isPunct() const;
-    int digitValue() const;
     QChar lower() const;
     QChar upper() const;
-    Direction direction() const;
 
 private:
     unsigned short c;
@@ -118,42 +105,7 @@ inline bool QChar::isSpace() const
 {
     // Use isspace() for basic Latin-1.
     // This will include newlines, which aren't included in unicode DirWS.
-    return c <= 0x7F ? isspace(c) : direction() == DirWS;
-}
-
-inline bool QChar::isDigit() const
-{
-    // FIXME: If fast enough, we should just call u_isdigit directly.
-    return c <= 0x7F ? isdigit(c) : u_isdigit(c);
-}
-
-inline bool QChar::isLetter() const
-{
-    // FIXME: If fast enough, we should just call u_isalpha directly.
-    return c <= 0x7F ? isalpha(c) : u_isalpha(c);
-}
-
-inline bool QChar::isNumber() const
-{
-    // FIXME: If fast enough, we should just call u_isdigit directly.
-    return c <= 0x7F ? isdigit(c) : u_isdigit(c);
-}
-
-inline bool QChar::isLetterOrNumber() const
-{
-    // FIXME: If fast enough, we should just call u_isalnum directly.
-    return c <= 0x7F ? isalnum(c) : u_isalnum(c);
-}
-
-inline bool QChar::isPunct() const
-{
-    return u_ispunct(c);
-}
-
-inline int QChar::digitValue() const
-{
-    // FIXME: If fast enough, we should just call u_charDigitValue directly.
-    return c <= '9' ? c - '0' : u_charDigitValue(c);
+    return c <= 0x7F ? isspace(c) : (u_charDirection(c) == U_WHITE_SPACE_NEUTRAL);
 }
 
 inline QChar QChar::lower() const
@@ -168,11 +120,6 @@ inline QChar QChar::upper() const
     return c <= 0x7F ? toupper(c) : u_toupper(c);
 }
 
-inline QChar::Direction QChar::direction() const
-{
-    return static_cast<Direction>(u_charDirection(c));
-}
-
 inline char QChar::latin1() const
 {
     return c > 0xff ? 0 : c;
index 971a98e..9009e68 100644 (file)
@@ -76,7 +76,7 @@ void Font::update() const
     m_fontList->invalidate();
 }
 
-int Font::width(const QChar* chs, int slen, int pos, int len, int tabWidth, int xpos) const
+int Font::width(const UChar* chs, int slen, int pos, int len, int tabWidth, int xpos) const
 {
     // FIXME: Want to define an lroundf for win32.
 #if __APPLE__
index 1856890..268f516 100644 (file)
@@ -73,26 +73,25 @@ public:
     void update() const;
 
     void drawText(GraphicsContext*, const IntPoint&, int tabWidth, int xpos,
-                  const QChar*, int len, int from, int to, int toAdd, 
+                  const UChar*, int len, int from, int to, int toAdd, 
                   TextDirection, bool visuallyOrdered) const;
     void drawHighlightForText(GraphicsContext*, const IntPoint&, int h, int tabWidth, int xpos,
-                              const QChar*, int len, int from, int to, int toAdd, 
+                              const UChar*, int len, int from, int to, int toAdd, 
                               TextDirection d, bool visuallyOrdered, const Color& backgroundColor) const;
     void drawLineForText(GraphicsContext*, const IntPoint&, int yOffset, int width) const;
     void drawLineForMisspelling(GraphicsContext*, const IntPoint&, int width) const;
     int misspellingLineThickness(GraphicsContext*) const;
 
-    float floatWidth(const QChar*, int slen, int pos, int len, int tabWidth, int xpos, bool runRounding = true) const;
+    float floatWidth(const UChar*, int slen, int pos, int len, int tabWidth, int xpos, bool runRounding = true) const;
     
-    int checkSelectionPoint(const QChar*, int slen, int pos, int len, int toAdd, int tabWidth, int xpos,
+    int checkSelectionPoint(const UChar*, int slen, int pos, int len, int toAdd, int tabWidth, int xpos,
         int x, TextDirection, bool visuallyOrdered, bool includePartialGlyphs) const;
     IntRect selectionRectForText(const IntPoint&, int h, int tabWidth, int xpos, 
-        const QChar*, int slen, int pos, int len, int width,
+        const UChar*, int slen, int pos, int len, int width,
         bool rtl, bool visuallyOrdered = false, int from = -1, int to = -1) const;
     
-    int width(const QChar*, int slen, int pos, int len, int tabWidth, int xpos) const;
-    int width(const QChar* chs, int slen, int tabWidth = 0, int xpos = 0) const { return width(chs, slen, 0, slen, tabWidth, xpos); }
-    int width(const DeprecatedString& s) const { return width(s.unicode(), s.length(), 0, 0); }
+    int width(const UChar*, int slen, int pos, int len, int tabWidth, int xpos) const;
+    int width(const UChar* chs, int slen, int tabWidth = 0, int xpos = 0) const { return width(chs, slen, 0, slen, tabWidth, xpos); }
 
     bool isSmallCaps() const { return m_fontDescription.smallCaps(); }
 
index 825a8b0..5e73fdd 100644 (file)
@@ -26,6 +26,7 @@
 #include "config.h"
 #include "GraphicsContext.h"
 
+#include "DeprecatedString.h"
 #include "Font.h"
 
 using namespace std;
@@ -192,21 +193,16 @@ void GraphicsContext::drawImage(Image* image, const IntRect& dest, const IntRect
 }
 
 // FIXME: We should consider removing this function and having callers just call the lower-level drawText directly.
-// FIXME: The int parameter should change to a HorizontalAlignment parameter.
-// FIXME: HorizontalAlignment should be moved into a separate header so it's not in Widget.h.
 // FIXME: We should consider changing this function to take a character pointer and length instead of a DeprecatedString.
-void GraphicsContext::drawText(const IntPoint& point, int horizontalAlignment, const DeprecatedString& str)
+void GraphicsContext::drawText(const IntPoint& point, const DeprecatedString& str)
 {
     if (paintingDisabled())
         return;
 
-    IntPoint p = point;
-    if (horizontalAlignment == AlignRight)
-        p.setX(p.x() - font().width(str.unicode(), str.length(), 0, 0));
-    drawText(p, 0, 0, str.unicode(), str.length(), 0, str.length(), 0);
+    drawText(point, 0, 0, reinterpret_cast<const UChar*>(str.unicode()), str.length(), 0, str.length(), 0);
 }
 
-void GraphicsContext::drawText(const IntPoint& point, int tabWidth, int xpos, const QChar *str, int slen, int pos, int len, int toAdd,
+void GraphicsContext::drawText(const IntPoint& point, int tabWidth, int xpos, const UChar* str, int slen, int pos, int len, int toAdd,
                                TextDirection d, bool visuallyOrdered, int from, int to)
 {
     if (paintingDisabled())
@@ -219,7 +215,7 @@ void GraphicsContext::drawText(const IntPoint& point, int tabWidth, int xpos, co
     font().drawText(this, point, tabWidth, xpos, str + pos, length, from, to, toAdd, d, visuallyOrdered);
 }
 
-void GraphicsContext::drawHighlightForText(const IntPoint& point, int h, int tabWidth, int xpos, const QChar *str, int slen, int pos, int len, int toAdd,
+void GraphicsContext::drawHighlightForText(const IntPoint& point, int h, int tabWidth, int xpos, const UChar* str, int slen, int pos, int len, int toAdd,
                                            TextDirection d, bool visuallyOrdered, int from, int to, const Color& backgroundColor)
 {
     if (paintingDisabled())
index d847718..d7d8c5e 100644 (file)
@@ -32,6 +32,7 @@
 #include "Pen.h"
 #include "TextDirection.h"
 #include <wtf/Noncopyable.h>
+#include <unicode/umachine.h>
 
 #if __APPLE__
 typedef struct CGContext PlatformGraphicsContext;
@@ -43,7 +44,6 @@ typedef void PlatformGraphicsContext;
 #endif
 
 class DeprecatedString;
-class QChar;
 
 namespace WebCore {
 
@@ -106,14 +106,14 @@ namespace WebCore {
         void setFocusRingClip(const IntRect&);
         void clearFocusRingClip();
 
-        void drawText(const IntPoint&, int alignmentFlags, const DeprecatedString&);
+        void drawText(const IntPoint&, const DeprecatedString&);
+        void drawText(const IntPoint&, int tabWidth, int xpos,
+            const UChar*, int slen, int pos, int len, int toAdd,
+            TextDirection = LTR, bool visuallyOrdered = false, int from = -1, int to = -1);
         void drawHighlightForText(const IntPoint&, int h, int tabWidth, int xpos,
-            const QChar*, int slen, int pos, int len, int toAdd,
+            const UChar*, int slen, int pos, int len, int toAdd,
             TextDirection, bool visuallyOrdered,
             int from, int to, const Color& backgroundColor);
-        void drawText(const IntPoint&, int tabWidth, int xpos,
-            const QChar*, int slen, int pos, int len, int toAdd,
-            TextDirection = LTR, bool visuallyOrdered = false, int from = -1, int to = -1);
         void drawLineForText(const IntPoint&, int yOffset, int width);
         void drawLineForMisspelling(const IntPoint&, int width);
         int misspellingLineThickness();
index c57bbc4..62f6c83 100644 (file)
@@ -38,14 +38,10 @@ namespace WebCore {
  * we plan to change this to have immutable copy on write semantics.
  */
 
-// FIXME: Move to unsigned short instead of QChar.
-
 class String {
 public:
     String() { } // gives null string, distinguishable from an empty string
-    String(QChar c) : m_impl(new StringImpl(&c, 1)) { }
-    String(const QChar*, unsigned length);
-    String(const DeprecatedString&);
+    String(const UChar*, unsigned length);
     String(const KJS::Identifier&);
     String(const KJS::UString&);
     String(const char*);
@@ -55,17 +51,16 @@ public:
     operator KJS::Identifier() const;
     operator KJS::UString() const;
 
-    String& operator +=(const String&);
-
-    void insert(const String&, unsigned pos);
+    unsigned length() const;
+    const UChar* characters() const;
 
-    const QChar& operator[](unsigned i) const; // if i >= length(), returns 0
+    UChar operator[](unsigned i) const; // if i >= length(), returns 0
     
-    bool contains(QChar c) const { return find(c) != -1; }
+    bool contains(UChar c) const { return find(c) != -1; }
     bool contains(const char* str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
     bool contains(const String& str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
 
-    int find(QChar c, int start = 0) const
+    int find(UChar c, int start = 0) const
         { return m_impl ? m_impl->find(c, start) : -1; }
     int find(const char* str, int start = 0, bool caseSensitive = true) const
         { return m_impl ? m_impl->find(str, start, caseSensitive) : -1; }
@@ -77,11 +72,13 @@ public:
     bool endsWith(const String& s, bool caseSensitive = true) const
         { return m_impl ? m_impl->endsWith(s.impl(), caseSensitive) : s.isEmpty(); }
 
-    String& replace(QChar a, QChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
-    String& replace(QChar a, const String& b) { if (m_impl) m_impl = m_impl->replace(a, b.impl()); return *this; }
+    void append(const String&);
+    void insert(const String&, unsigned pos);
+
+    String& replace(UChar a, UChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
+    String& replace(UChar a, const String& b) { if (m_impl) m_impl = m_impl->replace(a, b.impl()); return *this; }
     String& replace(unsigned index, unsigned len, const String& b) { if (m_impl) m_impl = m_impl->replace(index, len, b.impl()); return *this; }
 
-    unsigned length() const;
     void truncate(unsigned len);
     void remove(unsigned pos, int len = 1);
 
@@ -96,9 +93,9 @@ public:
     String lower() const;
     String upper() const;
 
-    const QChar* unicode() const;
-    DeprecatedString deprecatedString() const;
-    
+    // Return the string with case folded for case insensitive comparison.
+    String foldCase() const;
+
     static String number(int);
     static String number(unsigned);
     static String number(long);
@@ -107,9 +104,9 @@ public:
     
     static String sprintf(const char *, ...)
 #if __GNUC__
-    __attribute__ ((format (printf, 1, 2)))
+        __attribute__ ((format (printf, 1, 2)))
 #endif
-    ;
+        ;
 
     int toInt(bool* ok = 0) const;
     Length* toLengthArray(int& len) const;
@@ -137,6 +134,9 @@ public:
     const char *ascii() const;
 #endif
 
+    String(const DeprecatedString&);
+    DeprecatedString deprecatedString() const;
+    
 private:
     RefPtr<StringImpl> m_impl;
 };
@@ -144,10 +144,8 @@ private:
 String operator+(const String&, const String&);
 String operator+(const String&, const char*);
 String operator+(const char*, const String&);
-String operator+(const String&, QChar);
-String operator+(QChar, const String&);
-String operator+(const String&, char);
-String operator+(char, const String&);
+
+inline String& operator+=(String& a, const String& b) { a.append(b); return a; }
 
 inline bool operator==(const String& a, const String& b) { return equal(a.impl(), b.impl()); }
 inline bool operator==(const String& a, const char* b) { return equal(a.impl(), b); }
@@ -162,7 +160,7 @@ inline bool equalIgnoringCase(const String& a, const char* b) { return equalIgno
 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 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); }
 
index b4d31e8..c10f755 100644 (file)
@@ -56,9 +56,9 @@ const SegmentedString& SegmentedString::operator=(const SegmentedString &other)
 unsigned SegmentedString::length() const
 {
     unsigned length = m_currentString.m_length;
-    if (m_pushedChar1.unicode()) {
+    if (m_pushedChar1) {
         ++length;
-        if (m_pushedChar2.unicode())
+        if (m_pushedChar2)
             ++length;
     }
     if (m_composite) {
@@ -118,7 +118,7 @@ void SegmentedString::append(const SegmentedString &s)
         for (; i != e; ++i)
             append(*i);
     }
-    m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
+    m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
 }
 
 void SegmentedString::prepend(const SegmentedString &s)
@@ -132,7 +132,7 @@ void SegmentedString::prepend(const SegmentedString &s)
             prepend(*i);
     }
     prepend(s.m_currentString);
-    m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
+    m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
 }
 
 void SegmentedString::advanceSubstring()
@@ -150,9 +150,9 @@ void SegmentedString::advanceSubstring()
 DeprecatedString SegmentedString::toString() const
 {
     DeprecatedString result;
-    if (m_pushedChar1.unicode()) {
+    if (m_pushedChar1) {
         result.append(m_pushedChar1);
-        if (m_pushedChar2.unicode())
+        if (m_pushedChar2)
             result.append(m_pushedChar2);
     }
     m_currentString.appendTo(result);
index c3559fe..d2a0d88 100644 (file)
@@ -1,7 +1,7 @@
 /*
     This file is part of the KDE libraries
 
-    Copyright (C) 2004-6 Apple Computer
+    Copyright (C) 2004, 2005, 2006 Apple Computer
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
-//----------------------------------------------------------------------------
-//
-// KDE HTML Widget -- String class
 
-#ifndef KHTMLSTRING_H
-#define KHTMLSTRING_H
+#ifndef SegmentedString_h
+#define SegmentedString_h
 
+#include "DeprecatedString.h"
 #include "DeprecatedValueList.h"
 #include "PlatformString.h"
 #include <assert.h>
@@ -39,34 +37,41 @@ private:
     
     SegmentedSubstring() : m_length(0), m_current(0) {}
     SegmentedSubstring(const DeprecatedString &str) : m_string(str), m_length(str.length()) {
-        m_current = m_length == 0 ? 0 : m_string.stableUnicode();
+        m_current = m_length == 0 ? 0 : reinterpret_cast<const UChar*>(m_string.stableUnicode());
     }
 
-    SegmentedSubstring(const QChar *str, int length) : m_length(length), m_current(length == 0 ? 0 : str) {}
+    SegmentedSubstring(const UChar* str, int length) : m_length(length), m_current(length == 0 ? 0 : str) {}
 
     void clear() { m_length = 0; m_current = 0; }
     
-    void appendTo(DeprecatedString &str) const {
-        if (m_string.unicode() == m_current) {
+    void appendTo(DeprecatedStringstr) const {
+        if (reinterpret_cast<const UChar*>(m_string.unicode()) == m_current) {
             if (str.isEmpty())
                 str = m_string;
             else
                 str.append(m_string);
         } else {
-            str.insert(str.length(), m_current, m_length);
+            str.insert(str.length(), reinterpret_cast<const QChar*>(m_current), m_length);
         }
     }
 
     DeprecatedString m_string;
     int m_length;
-    const QChar *m_current;
+    const UChar* m_current;
 };
 
 class SegmentedString {
 public:
-    SegmentedString() : m_currentChar(0), m_lines(0), m_composite(false) {}
-    SegmentedString(const QChar *str, int length) : m_currentString(str, length), m_currentChar(m_currentString.m_current), m_lines(0), m_composite(false) {}
-    SegmentedString(const DeprecatedString &str) : m_currentString(str), m_currentChar(m_currentString.m_current), m_lines(0), m_composite(false) {}
+    SegmentedString()
+        : m_pushedChar1(0), m_pushedChar2(0), m_currentChar(0)
+        , m_lines(0), m_composite(false) {}
+    SegmentedString(const UChar* str, int length) : m_pushedChar1(0), m_pushedChar2(0)
+        , m_currentString(str, length), m_currentChar(m_currentString.m_current)
+        , m_lines(0), m_composite(false) {}
+    SegmentedString(const DeprecatedString &str)
+        : m_pushedChar1(0), m_pushedChar2(0), m_currentString(str)
+        , m_currentChar(m_currentString.m_current)
+        , m_lines(0), m_composite(false) {}
     SegmentedString(const SegmentedString&);
 
     const SegmentedString& operator=(const SegmentedString&);
@@ -76,12 +81,12 @@ public:
     void append(const SegmentedString &);
     void prepend(const SegmentedString &);
     
-    void push(QChar c) {
-        if (!m_pushedChar1.unicode()) {
+    void push(UChar c) {
+        if (!m_pushedChar1) {
             m_pushedChar1 = c;
-            m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
+            m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
         } else {
-            assert(!m_pushedChar2.unicode());
+            assert(!m_pushedChar2);
             m_pushedChar2 = c;
         }
     }
@@ -90,7 +95,7 @@ public:
     unsigned length() const;
 
     void advance() {
-        if (m_pushedChar1.unicode()) {
+        if (m_pushedChar1) {
             m_pushedChar1 = m_pushedChar2;
             m_pushedChar2 = 0;
         } else if (m_currentString.m_current) {
@@ -98,10 +103,10 @@ public:
             if (--m_currentString.m_length == 0)
                 advanceSubstring();
         }
-        m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
+        m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
     }
     
-    bool escaped() const { return m_pushedChar1.unicode(); }
+    bool escaped() const { return m_pushedChar1; }
 
     int lineCount() const { return m_lines; }
     void resetLineCount() { m_lines = 0; }
@@ -109,20 +114,20 @@ public:
     DeprecatedString toString() const;
 
     void operator++() { advance(); }
-    const QChar &operator*() const { return *current(); }
-    const QChar *operator->() const { return current(); }
+    const UChar& operator*() const { return *current(); }
+    const UChar* operator->() const { return current(); }
     
 private:
     void append(const SegmentedSubstring &);
     void prepend(const SegmentedSubstring &);
 
     void advanceSubstring();
-    const QChar *current() const { return m_currentChar; }
+    const UChar* current() const { return m_currentChar; }
 
-    QChar m_pushedChar1;
-    QChar m_pushedChar2;
+    UChar m_pushedChar1;
+    UChar m_pushedChar2;
     SegmentedSubstring m_currentString;
-    const QChar *m_currentChar;
+    const UChar* m_currentChar;
     DeprecatedValueList<SegmentedSubstring> m_substrings;
     int m_lines;
     bool m_composite;
index 416d558..9ab9acc 100644 (file)
@@ -44,7 +44,7 @@ StreamingTextDecoder::StreamingTextDecoder(const TextEncoding& encoding)
 
 static const UChar replacementCharacter = 0xFFFD;
 static const UChar BOM = 0xFEFF;
-static const int ConversionBufferSize = 16384;
+static const size_t ConversionBufferSize = 16384;
     
 static UConverter* cachedConverterICU;
 static TextEncodingID cachedConverterEncoding = InvalidEncoding;
@@ -59,12 +59,12 @@ StreamingTextDecoder::~StreamingTextDecoder()
     }
 }
 
-DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char *s, int length)
+DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned chars, int length)
 {
     ASSERT(m_numBufferedBytes == 0 || m_numBufferedBytes == 1);
 
-    const unsigned char *p = s;
-    unsigned len = length;
+    const unsigned charp = s;
+    size_t len = length;
     
     DeprecatedString result("");
     
@@ -79,7 +79,7 @@ DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char *s, int
             c = (m_bufferedBytes[0] << 8) | p[0];
 
         if (c)
-            result.append(reinterpret_cast<QChar *>(&c), 1);
+            result.append(reinterpret_cast<QChar*>(&c), 1);
 
         m_numBufferedBytes = 0;
         p += 1;
@@ -88,24 +88,24 @@ DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char *s, int
     
     while (len > 1) {
         UChar buffer[ConversionBufferSize];
-        int runLength = min(len / 2, (unsigned)(sizeof(buffer) / sizeof(buffer[0])));
+        int runLength = min(len / 2, ConversionBufferSize);
         int bufferLength = 0;
         if (m_littleEndian) {
             for (int i = 0; i < runLength; ++i) {
                 UChar c = p[0] | (p[1] << 8);
                 p += 2;
-                if (c && c != BOM)
+                if (c != BOM)
                     buffer[bufferLength++] = c;
             }
         } else {
             for (int i = 0; i < runLength; ++i) {
                 UChar c = (p[0] << 8) | p[1];
                 p += 2;
-                if (c && c != BOM)
+                if (c != BOM)
                     buffer[bufferLength++] = c;
             }
         }
-        result.append(reinterpret_cast<QChar *>(buffer), bufferLength);
+        result.append(reinterpret_cast<QChar*>(buffer), bufferLength);
         len -= runLength * 2;
     }
     
@@ -118,6 +118,35 @@ DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char *s, int
     return result;
 }
 
+bool StreamingTextDecoder::convertIfASCII(const unsigned char* s, int length, DeprecatedString& str)
+{
+    ASSERT(m_numBufferedBytes == 0 || m_numBufferedBytes == 1);
+
+    DeprecatedString result("");
+    result.reserve(length);
+
+    const unsigned char* p = s;
+    size_t len = length;
+    unsigned char ored = 0;
+    while (len) {
+        UChar buffer[ConversionBufferSize];
+        int runLength = min(len, ConversionBufferSize);
+        int bufferLength = 0;
+        for (int i = 0; i < runLength; ++i) {
+            unsigned char c = *p++;
+            ored |= c;
+            buffer[bufferLength++] = c;
+        }
+        if (ored & 0x80)
+            return false;
+        result.append(reinterpret_cast<QChar*>(buffer), bufferLength);
+        len -= runLength;
+    }
+
+    str = result;
+    return true;
+}
+
 static inline TextEncoding effectiveEncoding(const TextEncoding& encoding)
 {
     TextEncodingID id = encoding.encodingID();
@@ -126,7 +155,7 @@ static inline TextEncoding effectiveEncoding(const TextEncoding& encoding)
     return TextEncoding(id, encoding.flags());
 }
 
-UErrorCode StreamingTextDecoder::createICUConverter()
+void StreamingTextDecoder::createICUConverter()
 {
     TextEncoding encoding = effectiveEncoding(m_encoding);
     const char* encodingName = encoding.name();
@@ -141,16 +170,13 @@ UErrorCode StreamingTextDecoder::createICUConverter()
         UErrorCode err = U_ZERO_ERROR;
         ASSERT(!m_converterICU);
         m_converterICU = ucnv_open(encodingName, &err);
+#if !LOG_DISABLED
         if (err == U_AMBIGUOUS_ALIAS_WARNING)
             LOG_ERROR("ICU ambiguous alias warning for encoding: %s", encodingName);
-
-        if (!m_converterICU) {
+        if (!m_converterICU)
             LOG_ERROR("the ICU Converter won't convert from text encoding 0x%X, error %d", encoding.encodingID(), err);
-            return err;
-        }
+#endif
     }
-    
-    return U_ZERO_ERROR;
 }
 
 // We strip replacement characters because the ICU converter for UTF-8 converts
@@ -162,7 +188,7 @@ static inline bool unwanted(UChar c)
     return c == replacementCharacter || c == BOM;
 }
 
-void StreamingTextDecoder::appendOmittingUnwanted(DeprecatedString &s, const UChar *characters, int byteCount)
+void StreamingTextDecoder::appendOmittingUnwanted(DeprecatedString& s, const UChar* characters, int byteCount)
 {
     ASSERT(byteCount % sizeof(UChar) == 0);
     int start = 0;
@@ -170,38 +196,39 @@ void StreamingTextDecoder::appendOmittingUnwanted(DeprecatedString &s, const UCh
     for (int i = 0; i != characterCount; ++i) {
         if (unwanted(characters[i])) {
             if (start != i)
-                s.append(reinterpret_cast<const QChar *>(&characters[start]), i - start);
+                s.append(reinterpret_cast<const QChar*>(&characters[start]), i - start);
             start = i + 1;
         }
     }
     if (start != characterCount)
-        s.append(reinterpret_cast<const QChar *>(&characters[start]), characterCount - start);
+        s.append(reinterpret_cast<const QChar*>(&characters[start]), characterCount - start);
 }
 
-DeprecatedString StreamingTextDecoder::convertUsingICU(const unsigned char *chs, int len, bool flush)
+DeprecatedString StreamingTextDecoder::convertUsingICU(const unsigned charchs, int len, bool flush)
 {
     // Get a converter for the passed-in encoding.
-    if (!m_converterICU && U_FAILURE(createICUConverter()))
-        return DeprecatedString();
-
-    ASSERT(m_converterICU);
+    if (!m_converterICU) {
+        createICUConverter();
+        if (!m_converterICU)
+            return DeprecatedString();
+    }
 
     DeprecatedString result("");
     result.reserve(len);
 
     UChar buffer[ConversionBufferSize];
-    const char *source = reinterpret_cast<const char *>(chs);
-    const char *sourceLimit = source + len;
-    int32_t *offsets = NULL;
+    const char* source = reinterpret_cast<const char*>(chs);
+    const charsourceLimit = source + len;
+    int32_toffsets = NULL;
     UErrorCode err;
-    
+
     do {
-        UChar *target = buffer;
-        const UChar *targetLimit = target + ConversionBufferSize;
+        UChartarget = buffer;
+        const UChartargetLimit = target + ConversionBufferSize;
         err = U_ZERO_ERROR;
         ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err);
         int count = target - buffer;
-        appendOmittingUnwanted(result, reinterpret_cast<const UChar *>(buffer), count * sizeof(UChar));
+        appendOmittingUnwanted(result, reinterpret_cast<const UChar*>(buffer), count * sizeof(UChar));
     } while (err == U_BUFFER_OVERFLOW_ERROR);
 
     if (U_FAILURE(err)) {
@@ -215,39 +242,57 @@ DeprecatedString StreamingTextDecoder::convertUsingICU(const unsigned char *chs,
         LOG_ERROR("ICU conversion error");
         return DeprecatedString();
     }
-    
+
     return result;
 }
 
-DeprecatedString StreamingTextDecoder::convert(const unsigned char *chs, int len, bool flush)
+DeprecatedString StreamingTextDecoder::convert(const unsigned charchs, int len, bool flush)
 {
-    //#define PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE 1000
-
     switch (m_encoding.encodingID()) {
-    case UTF16Encoding:
-        return convertUTF16(chs, len);
+        case UTF16Encoding:
+            return convertUTF16(chs, len);
+
+        case ASCIIEncoding:
+        case Latin1Encoding:
+        case WinLatin1Encoding: {
+            DeprecatedString result;
+            if (convertIfASCII(chs, len, result))
+                return result;
+            break;
+        }
 
-    default:
-#if PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE
-        DeprecatedString result;
-        int chunkSize;
-        for (int i = 0; i != len; i += chunkSize) {
-            chunkSize = len - i;
-            if (chunkSize > PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE) {
-                chunkSize = PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE;
+        case UTF8Encoding:
+            // If a previous run used ICU, we might have a partly converted character.
+            // If so, don't use the optimized ASCII code path.
+            if (!m_converterICU) {
+                DeprecatedString result;
+                if (convertIfASCII(chs, len, result))
+                    return result;
             }
-            result += convertUsingICU(chs + i, chunkSize, flush && (i + chunkSize == len));
+            break;
+
+        default:
+            break;
+    }
+
+    //#define PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE 1000
+#if PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE
+    DeprecatedString result;
+    int chunkSize;
+    for (int i = 0; i != len; i += chunkSize) {
+        chunkSize = len - i;
+        if (chunkSize > PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE) {
+            chunkSize = PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE;
         }
-        return result;
+        result += convertUsingICU(chs + i, chunkSize, flush && (i + chunkSize == len));
+    }
+    return result;
 #else
-        return convertUsingICU(chs, len, flush);
+    return convertUsingICU(chs, len, flush);
 #endif
-    }
-    ASSERT_NOT_REACHED();
-    return DeprecatedString();
 }
 
-DeprecatedString StreamingTextDecoder::toUnicode(const char *chs, int len, bool flush)
+DeprecatedString StreamingTextDecoder::toUnicode(const charchs, int len, bool flush)
 {
     ASSERT_ARG(len, len >= 0);
     
@@ -265,8 +310,8 @@ DeprecatedString StreamingTextDecoder::toUnicode(const char *chs, int len, bool
     int numBufferedBytes = m_numBufferedBytes;
     int buf1Len = numBufferedBytes;
     int buf2Len = len;
-    const unsigned char *buf1 = m_bufferedBytes;
-    const unsigned char *buf2 = reinterpret_cast<const unsigned char *>(chs);
+    const unsigned charbuf1 = m_bufferedBytes;
+    const unsigned char* buf2 = reinterpret_cast<const unsigned char*>(chs);
     unsigned char c1 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
     unsigned char c2 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
     unsigned char c3 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
index a395ed7..bf8b2cd 100644 (file)
@@ -37,20 +37,21 @@ namespace WebCore {
     public:
         StreamingTextDecoder(const TextEncoding&);
         ~StreamingTextDecoder();
-        
+
         DeprecatedString toUnicode(const char* chs, int len, bool flush = false);
-        
+
     private:
-        DeprecatedString convert(const char*chs, int len, bool flush)
+        DeprecatedString convert(const char* chs, int len, bool flush)
             { return convert(reinterpret_cast<const unsigned char*>(chs), len, flush); }
         DeprecatedString convert(const unsigned char* chs, int len, bool flush);
-        DeprecatedString convertUTF16(const unsigned char* chs, int len);
-        
-        // ICU decoding.
-        DeprecatedString convertUsingICU(const unsigned char *chs, int len, bool flush);
-        UErrorCode createICUConverter();
 
-        static void appendOmittingUnwanted(DeprecatedString& s, const UChar* characters, int byteCount);
+        bool convertIfASCII(const unsigned char*, int len, DeprecatedString&);
+        DeprecatedString convertUTF16(const unsigned char*, int len);
+        DeprecatedString convertUsingICU(const unsigned char*, int len, bool flush);
+
+        void createICUConverter();
+
+        static void appendOmittingUnwanted(DeprecatedString&, const UChar* characters, int byteCount);
 
         TextEncoding m_encoding;
         bool m_littleEndian;
index a1bb5f7..a2d80eb 100644 (file)
 #include "config.h"
 #include "PlatformString.h"
 
+#include "DeprecatedString.h"
 #include <kjs/identifier.h>
 #include <wtf/Vector.h>
 #include <stdarg.h>
 
-using namespace KJS;
+using KJS::Identifier;
+using KJS::UString;
 
 namespace WebCore {
 
-String::String(const QChar* str, unsigned len)
+String::String(const UChar* str, unsigned len)
 {
     if (!str)
         return;
@@ -50,7 +52,7 @@ String::String(const DeprecatedString& str)
     if (str.isEmpty())
         m_impl = StringImpl::empty();
     else 
-        m_impl = new StringImpl(str.unicode(), str.length());
+        m_impl = new StringImpl(reinterpret_cast<const UChar*>(str.unicode()), str.length());
 }
 
 String::String(const char* str)
@@ -76,18 +78,17 @@ String::String(const char* str, unsigned length)
         m_impl = new StringImpl(str, length);
 }
 
-String& String::operator+=(const String &str)
+void String::append(const String &str)
 {
     if (str.m_impl) {
         if (!m_impl) {
             // ### FIXME!!!
             m_impl = str.m_impl;
-            return *this;
+            return;
         }
         m_impl = m_impl->copy();
         m_impl->append(str.m_impl.get());
     }
-    return *this;
 }
 
 String operator+(const String& a, const String& b)
@@ -111,26 +112,6 @@ String operator+(const char* cs, const String& s)
     return String(cs) + s;
 }
 
-String operator+(const String& s, QChar c)
-{
-    return s + String(c);
-}
-
-String operator+(QChar c, const String& s)
-{
-    return String(c) + s;
-}
-
-String operator+(const String& s, char c)
-{
-    return s + String(c);
-}
-
-String operator+(char c, const String& s)
-{
-    return String(c) + s;
-}
-
 void String::insert(const String& str, unsigned pos)
 {
     if (!m_impl)
@@ -139,12 +120,11 @@ void String::insert(const String& str, unsigned pos)
         m_impl->insert(str.m_impl.get(), pos);
 }
 
-const QChar& String::operator[](unsigned i) const
+UChar String::operator[](unsigned i) const
 {
-    static const QChar nullChar = 0;
-    if (!m_impl || i >= m_impl->length() )
-        return nullChar;
-    return *(m_impl->unicode()+i);
+    if (!m_impl || i >= m_impl->length())
+        return 0;
+    return m_impl->characters()[i];
 }
 
 unsigned String::length() const
@@ -194,32 +174,39 @@ String String::upper() const
     return m_impl->upper();
 }
 
+String String::foldCase() const
+{
+    if (!m_impl)
+        return String();
+    return m_impl->foldCase();
+}
+
 bool String::percentage(int& result) const
 {
     if (!m_impl || !m_impl->length())
         return false;
 
-    if (*(m_impl->unicode()+m_impl->length()-1) != '%')
+    if ((*m_impl)[m_impl->length() - 1] != '%')
        return false;
 
-    result = QConstString(m_impl->unicode(), m_impl->length()-1).string().toInt();
+    result = QConstString(reinterpret_cast<const QChar*>(m_impl->characters()), m_impl->length() - 1).string().toInt();
     return true;
 }
 
-const QChar* String::unicode() const
+const UChar* String::characters() const
 {
     if (!m_impl)
         return 0;
-    return m_impl->unicode();
+    return m_impl->characters();
 }
 
 DeprecatedString String::deprecatedString() const
 {
     if (!m_impl)
         return DeprecatedString::null;
-    if (!m_impl->unicode())
+    if (!m_impl->characters())
         return DeprecatedString("", 0);
-    return DeprecatedString(m_impl->unicode(), m_impl->length());
+    return DeprecatedString(reinterpret_cast<const QChar*>(m_impl->characters()), m_impl->length());
 }
 
 String String::sprintf(const char *format, ...)
@@ -229,14 +216,14 @@ String String::sprintf(const char *format, ...)
 
     Vector<char, 256> buffer;
 #if PLATFORM(WIN_OS)
-    // Windows vnsprintf does not return the expected size on overflow
+    // Windows vsnprintf does not return the expected size on overflow
     // So we just have to keep looping until our vsprintf call works!
     int result = 0;
     do {
         if (result < 0)
             buffer.resize(buffer.capacity() * 2);
         result = vsnprintf(buffer.data(), buffer.capacity(), format, args);
-        // Windows vnsprintf returns -1 both for all errors.  There is no
+        // Windows vsnprintf returns -1 for both errors. Since there is no
         // way to distinguish between "not enough room" and "invalid format"
         // we just keep trying until we hit an arbitrary size and then stop.
     } while (result < 0 && (buffer.capacity() * 2) < 2048);
@@ -308,7 +295,7 @@ String String::copy() const
 
 bool String::isEmpty() const
 {
-    return (!m_impl || m_impl->length() == 0);
+    return !m_impl || !m_impl->length();
 }
 
 Length* String::toCoordsArray(int& len) const 
@@ -333,7 +320,7 @@ bool operator==(const String& a, const DeprecatedString& b)
     unsigned l = a.length();
     if (l != b.length())
         return false;
-    if (!memcmp(a.unicode(), b.unicode(), l * sizeof(QChar)))
+    if (!memcmp(a.characters(), b.unicode(), l * sizeof(UChar)))
         return true;
     return false;
 }
@@ -346,7 +333,7 @@ String::String(const Identifier& str)
     if (str.isEmpty())
         m_impl = StringImpl::empty();
     else 
-        m_impl = new StringImpl(reinterpret_cast<const QChar*>(str.data()), str.size());
+        m_impl = new StringImpl(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 String::String(const UString& str)
@@ -357,21 +344,21 @@ String::String(const UString& str)
     if (str.isEmpty())
         m_impl = StringImpl::empty();
     else 
-        m_impl = new StringImpl(reinterpret_cast<const QChar*>(str.data()), str.size());
+        m_impl = new StringImpl(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 String::operator Identifier() const
 {
     if (!m_impl)
         return Identifier();
-    return Identifier(reinterpret_cast<const KJS::UChar*>(m_impl->unicode()), m_impl->length());
+    return Identifier(reinterpret_cast<const KJS::UChar*>(m_impl->characters()), m_impl->length());
 }
 
 String::operator UString() const
 {
     if (!m_impl)
         return UString();
-    return UString(reinterpret_cast<const KJS::UChar*>(m_impl->unicode()), m_impl->length());
+    return UString(reinterpret_cast<const KJS::UChar*>(m_impl->characters()), m_impl->length());
 }
 
 }
index 119444b..0e378a4 100644 (file)
@@ -24,6 +24,8 @@
 #include "AtomicStringImpl.h"
 #include "PlatformString.h"
 #include <wtf/HashTraits.h>
+#include <unicode/uchar.h>
+#include <unicode/ustring.h>
 
 namespace WTF {
 
@@ -43,8 +45,8 @@ namespace WTF {
             if (aLength != bLength)
                 return false;
 
-            const uint32_t* aChars = reinterpret_cast<const uint32_t*>(a->unicode());
-            const uint32_t* bChars = reinterpret_cast<const uint32_t*>(b->unicode());
+            const uint32_t* aChars = reinterpret_cast<const uint32_t*>(a->characters());
+            const uint32_t* bChars = reinterpret_cast<const uint32_t*>(b->characters());
 
             unsigned halfLength = aLength >> 1;
             for (unsigned i = 0; i != halfLength; ++i)
@@ -68,7 +70,7 @@ namespace WTF {
         static unsigned hash(const WebCore::StringImpl* str)
         {
             unsigned l = str->length();
-            const QChar* s = str->unicode();
+            const UChar* s = str->characters();
             uint32_t hash = PHI;
             uint32_t tmp;
             
@@ -77,8 +79,8 @@ namespace WTF {
             
             // Main loop
             for (; l > 0; l--) {
-                hash += s[0].lower().unicode();
-                tmp = (s[1].lower().unicode() << 11) ^ hash;
+                hash += u_foldCase(s[0], U_FOLD_CASE_DEFAULT);
+                tmp = (u_foldCase(s[1], U_FOLD_CASE_DEFAULT) << 11) ^ hash;
                 hash = (hash << 16) ^ tmp;
                 s += 2;
                 hash += hash >> 11;
@@ -86,7 +88,7 @@ namespace WTF {
             
             // Handle end case
             if (rem) {
-                hash += s[0].lower().unicode();
+                hash += u_foldCase(s[0], U_FOLD_CASE_DEFAULT);
                 hash ^= hash << 11;
                 hash += hash >> 17;
             }
@@ -123,8 +125,8 @@ namespace WTF {
             
             // Main loop
             for (; l > 0; l--) {
-                hash += QChar(s[0]).lower().unicode();
-                tmp = (QChar(s[1]).lower().unicode() << 11) ^ hash;
+                hash += u_foldCase(s[0], U_FOLD_CASE_DEFAULT);
+                tmp = (u_foldCase(s[1], U_FOLD_CASE_DEFAULT) << 11) ^ hash;
                 hash = (hash << 16) ^ tmp;
                 s += 2;
                 hash += hash >> 11;
@@ -132,7 +134,7 @@ namespace WTF {
             
             // Handle end case
             if (rem) {
-                hash += QChar(s[0]).lower().unicode();
+                hash += u_foldCase(s[0], U_FOLD_CASE_DEFAULT);
                 hash ^= hash << 11;
                 hash += hash >> 17;
             }
@@ -155,22 +157,18 @@ namespace WTF {
         
         static bool equal(const WebCore::StringImpl* a, const WebCore::StringImpl* b)
         {
-            if (a == b) return true;
-            if (!a || !b) return false;
+            if (a == b)
+                return true;
+            if (!a || !b)
+                return false;
             unsigned length = a->length();
             if (length != b->length())
                 return false;
-            const QChar* as = a->unicode();
-            const QChar* bs = b->unicode();
-            for (unsigned i = 0; i != length; ++i)
-                if (as[i].lower() != bs[i].lower())
-                    return false;
-            return true;
+            return u_memcasecmp(a->characters(), b->characters(), length, U_FOLD_CASE_DEFAULT) == 0;
         }
     };
 
-    template<> struct StrHash<WebCore::AtomicStringImpl*> : public StrHash<WebCore::StringImpl*> {
-    };
+    template<> struct StrHash<WebCore::AtomicStringImpl*> : public StrHash<WebCore::StringImpl*> { };
 
     template<> struct StrHash<RefPtr<WebCore::StringImpl> > {
         static unsigned hash(const RefPtr<WebCore::StringImpl>& key) { return key->hash(); }
index c7c4ed1..9c90952 100644 (file)
 #include "StringImpl.h"
 
 #include "AtomicString.h"
+#include "DeprecatedString.h"
 #include "Length.h"
 #include "StringHash.h"
 #include <kjs/identifier.h>
 #include <wtf/Assertions.h>
 #include <unicode/ubrk.h>
+#include <unicode/ustring.h>
 #include <assert.h>
 
-using namespace KJS;
 using namespace WTF;
 
+using KJS::Identifier;
+using KJS::UString;
+
 namespace WebCore {
 
-static inline QChar* newQCharVector(unsigned n)
+const UChar nonBreakingSpace = 0xA0;
+
+static inline UChar* newUCharVector(unsigned n)
 {
-    return static_cast<QChar*>(fastMalloc(sizeof(QChar) * n));
+    return static_cast<UChar*>(fastMalloc(sizeof(UChar) * n));
 }
 
-static inline void deleteQCharVector(QChar* p)
+static inline void deleteUCharVector(UChar* p)
 {
     fastFree(p);
 }
@@ -59,25 +65,25 @@ StringImpl* StringImpl::empty()
 
 StringImpl::StringImpl(const DeprecatedString& str)
 {
-    initWithQChar(str.unicode(), str.length());
+    init(reinterpret_cast<const UChar*>(str.unicode()), str.length());
 }
 
-StringImpl::StringImpl(const QChar* str, unsigned len)
+StringImpl::StringImpl(const UChar* str, unsigned len)
 {
-    initWithQChar(str, len);
+    init(str, len);
 }
 
 StringImpl::StringImpl(const char* str)
 {
-    initWithChar(str, strlen(str));
+    init(str, strlen(str));
 }
 
 StringImpl::StringImpl(const char* str, unsigned len)
 {
-    initWithChar(str, len);
+    init(str, len);
 }
 
-void StringImpl::initWithChar(const char* str, unsigned len)
+void StringImpl::init(const char* str, unsigned len)
 {
     m_hash = 0;
     m_inTable = false;
@@ -87,14 +93,14 @@ void StringImpl::initWithChar(const char* str, unsigned len)
         return;
     }
     
-    m_data = newQCharVector(m_length);
+    m_data = newUCharVector(m_length);
     int i = m_length;
-    QChar* ptr = m_data;
+    UChar* ptr = m_data;
     while (i--)
         *ptr++ = *str++;
 }
 
-void StringImpl::initWithQChar(const QChar* str, unsigned len)
+void StringImpl::init(const UChar* str, unsigned len)
 {
     m_hash = 0;
     m_inTable = false;
@@ -104,15 +110,15 @@ void StringImpl::initWithQChar(const QChar* str, unsigned len)
         return;
     }
     
-    m_data = newQCharVector(len);
-    memcpy(m_data, str, len * sizeof(QChar));
+    m_data = newUCharVector(len);
+    memcpy(m_data, str, len * sizeof(UChar));
 }
 
 StringImpl::~StringImpl()
 {
     if (m_inTable)
         AtomicString::remove(this);
-    deleteQCharVector(m_data);
+    deleteUCharVector(m_data);
 }
 
 void StringImpl::append(const StringImpl* str)
@@ -121,10 +127,10 @@ void StringImpl::append(const StringImpl* str)
     if(str && str->m_length != 0)
     {
         int newlen = m_length+str->m_length;
-        QChar* c = newQCharVector(newlen);
-        memcpy(c, m_data, m_length*sizeof(QChar));
-        memcpy(c+m_length, str->m_data, str->m_length*sizeof(QChar));
-        deleteQCharVector(m_data);
+        UChar* c = newUCharVector(newlen);
+        memcpy(c, m_data, m_length * sizeof(UChar));
+        memcpy(c + m_length, str->m_data, str->m_length * sizeof(UChar));
+        deleteUCharVector(m_data);
         m_data = c;
         m_length = newlen;
     }
@@ -139,11 +145,11 @@ void StringImpl::insert(const StringImpl* str, unsigned pos)
     }
     if (str && str->m_length != 0) {
         int newlen = m_length + str->m_length;
-        QChar* c = newQCharVector(newlen);
-        memcpy(c, m_data, pos*sizeof(QChar));
-        memcpy(c+pos, str->m_data, str->m_length*sizeof(QChar));
-        memcpy(c+pos+str->m_length, m_data+pos, (m_length-pos)*sizeof(QChar));
-        deleteQCharVector(m_data);
+        UChar* c = newUCharVector(newlen);
+        memcpy(c, m_data, pos * sizeof(UChar));
+        memcpy(c + pos, str->m_data, str->m_length * sizeof(UChar));
+        memcpy(c + pos + str->m_length, m_data + pos, (m_length - pos) * sizeof(UChar));
+        deleteUCharVector(m_data);
         m_data = c;
         m_length = newlen;
     }
@@ -155,9 +161,9 @@ void StringImpl::truncate(int len)
     if (len >= (int)m_length)
         return;
     int nl = len < 1 ? 1 : len;
-    QChar* c = newQCharVector(nl);
-    memcpy(c, m_data, nl*sizeof(QChar));
-    deleteQCharVector(m_data);
+    UChar* c = newUCharVector(nl);
+    memcpy(c, m_data, nl * sizeof(UChar));
+    deleteUCharVector(m_data);
     m_data = c;
     m_length = len;
 }
@@ -167,16 +173,16 @@ void StringImpl::remove(unsigned pos, int len)
     assert(!m_inTable);
     if (len <= 0)
         return;
-    if (pos >= m_length )
+    if (pos >= m_length)
         return;
     if ((unsigned)len > m_length - pos)
         len = m_length - pos;
 
     unsigned newLen = m_length-len;
-    QChar* c = newQCharVector(newLen);
-    memcpy(c, m_data, pos*sizeof(QChar));
-    memcpy(c+pos, m_data+pos+len, (m_length-len-pos)*sizeof(QChar));
-    deleteQCharVector(m_data);
+    UChar* c = newUCharVector(newLen);
+    memcpy(c, m_data, pos * sizeof(UChar));
+    memcpy(c + pos, m_data + pos + len, (m_length - len - pos) * sizeof(UChar));
+    deleteUCharVector(m_data);
     m_data = c;
     m_length = newLen;
 }
@@ -187,8 +193,8 @@ StringImpl* StringImpl::split(unsigned pos)
     if( pos >=m_length ) return new StringImpl();
 
     unsigned newLen = m_length-pos;
-    QChar* c = newQCharVector(newLen);
-    memcpy(c, m_data+pos, newLen*sizeof(QChar));
+    UChar* c = newUCharVector(newLen);
+    memcpy(c, m_data + pos, newLen * sizeof(UChar));
 
     StringImpl* str = new StringImpl(m_data + pos, newLen);
     truncate(pos);
@@ -204,16 +210,12 @@ bool StringImpl::containsOnlyWhitespace(unsigned from, unsigned len) const
 {
     if (!m_data)
         return true;
-    
-    for (unsigned i = from; i < len; i++) {
-        QChar c = m_data[i];
-        if (c.unicode() <= 0x7F) {
-            if (!isspace(c.unicode()))
-                return false;
-        } 
-        else
+    // FIXME: Both the definition of what whitespace is, and the definition of what
+    // the "len" parameter means are different here from what's done in RenderText.
+    // FIXME: No range checking here.
+    for (unsigned i = from; i < len; i++)
+        if (m_data[i] > 0x7F || !isspace(m_data[i]))
             return false;
-    }
     return true;
 }
     
@@ -226,51 +228,45 @@ StringImpl* StringImpl::substring(unsigned pos, unsigned len)
     return new StringImpl(m_data + pos, len);
 }
 
-static Length parseLength(const QChar* m_data, unsigned int m_length)
+static Length parseLength(const UChar* m_data, unsigned int m_length)
 {
     if (m_length == 0)
         return Length(1, Relative);
 
     unsigned i = 0;
-    while (i < m_length && m_data[i].isSpace())
+    while (i < m_length && QChar(m_data[i]).isSpace())
         ++i;
     if (i < m_length && (m_data[i] == '+' || m_data[i] == '-'))
         ++i;
-    while (i < m_length && m_data[i].isDigit())
+    while (i < m_length && u_isdigit(m_data[i]))
         ++i;
 
     bool ok;
-    int r = QConstString(m_data, i).string().toInt(&ok);
+    int r = QConstString(reinterpret_cast<const QChar*>(m_data), i).string().toInt(&ok);
 
     /* Skip over any remaining digits, we are not that accurate (5.5% => 5%) */
-    while (i < m_length && (m_data[i].isDigit() || m_data[i] == '.'))
+    while (i < m_length && (u_isdigit(m_data[i]) || m_data[i] == '.'))
         ++i;
 
     /* IE Quirk: Skip any whitespace (20 % => 20%) */
-    while (i < m_length && m_data[i].isSpace())
+    while (i < m_length && QChar(m_data[i]).isSpace())
         ++i;
 
     if (ok) {
-        if (i == m_length)
-            return Length(r, Fixed);
-        else {
-            const QChar* next = m_data+i;
-
-            if (*next == '%')
+        if (i < m_length) {
+            UChar next = m_data[i];
+            if (next == '%')
                 return Length(r, Percent);
-
-            if (*next == '*')
+            if (next == '*')
                 return Length(r, Relative);
         }
         return Length(r, Fixed);
     } else {
         if (i < m_length) {
-            const QChar* next = m_data + i;
-
-            if (*next == '*')
+            UChar next = m_data[i];
+            if (next == '*')
                 return Length(1, Relative);
-
-            if (*next == '%')
+            if (next == '%')
                 return Length(1, Relative);
         }
     }
@@ -284,17 +280,16 @@ Length StringImpl::toLength() const
 
 Length* StringImpl::toCoordsArray(int& len) const
 {
-    QChar* spacified = newQCharVector(m_length);
-    QChar space(' ');
-    for (unsigned int i=0; i < m_length; i++) {
-        QChar cc = m_data[i];
-        if (cc.unicode() > '9' || (cc.unicode() < '0' && cc != '-' && cc != '*' && cc != '.'))
-            spacified[i] = space;
+    UChar* spacified = newUCharVector(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;
     }
-    DeprecatedString str(spacified, m_length);
-    deleteQCharVector(spacified);
+    DeprecatedString str(reinterpret_cast<const QChar*>(spacified), m_length);
+    deleteUCharVector(spacified);
 
     str = str.simplifyWhiteSpace();
 
@@ -306,10 +301,10 @@ Length* StringImpl::toCoordsArray(int& len) const
     int pos2;
 
     while((pos2 = str.find(' ', pos)) != -1) {
-        r[i++] = parseLength(str.unicode() + pos, pos2-pos);
+        r[i++] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, pos2 - pos);
         pos = pos2+1;
     }
-    r[i] = parseLength(str.unicode() + pos, str.length()-pos);
+    r[i] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, str.length() - pos);
 
     return r;
 }
@@ -320,7 +315,7 @@ Length* StringImpl::toLengthArray(int& len) const
         len = 1;
         return 0;
     }
-    DeprecatedString str(m_data, m_length);
+    DeprecatedString str(reinterpret_cast<const QChar*>(m_data), m_length);
     str = str.simplifyWhiteSpace();
 
     len = str.contains(',') + 1;
@@ -330,14 +325,14 @@ Length* StringImpl::toLengthArray(int& len) const
     int pos = 0;
     int pos2;
 
-    while((pos2 = str.find(',', pos)) != -1) {
-        r[i++] = parseLength(str.unicode() + pos, pos2 - pos);
+    while ((pos2 = str.find(',', pos)) != -1) {
+        r[i++] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, pos2 - pos);
         pos = pos2+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.unicode() + pos, str.length() - pos);
+        r[i] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, str.length() - pos);
     else
         len--;
 
@@ -346,11 +341,22 @@ Length* StringImpl::toLengthArray(int& len) const
 
 bool StringImpl::isLower() const
 {
-    unsigned int i;
-    for (i = 0; i < m_length; i++)
-        if (m_data[i].lower() != m_data[i])
-            return false;
-    return true;
+    // Do a quick check for the case where it's all ASCII.
+    int allLower = true;
+    UChar ored = 0;
+    for (unsigned i = 0; i < m_length; i++) {
+        UChar c = m_data[i];
+        allLower &= islower(c);
+        ored |= c;
+    }
+    if (!(ored & ~0x7F))
+        return allLower;
+
+    // Do a slower check for the other cases.
+    UBool allLower2 = true;
+    for (unsigned i = 0; i < m_length; i++)
+        allLower2 &= u_islower(m_data[i]);
+    return allLower2;
 }
 
 StringImpl* StringImpl::lower() const
@@ -359,12 +365,43 @@ StringImpl* StringImpl::lower() const
     if (!m_length)
         return c;
 
-    c->m_data = newQCharVector(m_length);
-    c->m_length = m_length;
+    UChar* data = newUCharVector(m_length);
+    int length = m_length;
 
-    for (unsigned int i = 0; i < m_length; i++)
-        c->m_data[i] = m_data[i].lower();
+    c->m_data = data;
+    c->m_length = length;
 
+    // Do a faster loop for the case where it's all ASCII.
+    UChar ored = 0;
+    for (int i = 0; i < length; i++) {
+        UChar c = m_data[i];
+        ored |= c;
+        data[i] = tolower(c);
+    }
+    if (!(ored & ~0x7F))
+        return c;
+
+    UErrorCode status = U_ZERO_ERROR;
+    int32_t realLength = u_strToLower(data, length, m_data, length, "", &status);
+    if (U_SUCCESS(status) && realLength == length)
+        return c;
+
+    if (realLength > length) {
+        deleteUCharVector(data);
+        data = newUCharVector(realLength);
+    }
+    length = realLength;
+
+    c->m_data = data;
+    c->m_length = length;
+
+    status = U_ZERO_ERROR;
+    u_strToLower(data, length, m_data, m_length, "", &status);
+    if (U_FAILURE(status)) {
+        c->ref();
+        c->deref();
+        return copy();
+    }
     return c;
 }
 
@@ -373,17 +410,40 @@ StringImpl* StringImpl::upper() const
     StringImpl* c = new StringImpl;
     if (!m_length)
         return c;
+    UErrorCode status = U_ZERO_ERROR;
+    int32_t length = u_strToUpper(0, 0, m_data, m_length, "", &status);
+    c->m_data = newUCharVector(length);
+    c->m_length = length;
+    status = U_ZERO_ERROR;
+    u_strToUpper(c->m_data, length, m_data, m_length, "", &status);
+    if (U_FAILURE(status)) {
+        c->ref();
+        c->deref();
+        return copy();
+    }
+    return c;
+}
 
-    c->m_data = newQCharVector(m_length);
-    c->m_length = m_length;
-
-    for (unsigned int i = 0; i < m_length; i++)
-        c->m_data[i] = m_data[i].upper();
-
+StringImpl* StringImpl::foldCase() const
+{
+    StringImpl* c = new StringImpl;
+    if (!m_length)
+        return c;
+    UErrorCode status = U_ZERO_ERROR;
+    int32_t length = u_strFoldCase(0, 0, m_data, m_length, U_FOLD_CASE_DEFAULT, &status);
+    c->m_data = newUCharVector(length);
+    c->m_length = length;
+    status = U_ZERO_ERROR;
+    u_strFoldCase(c->m_data, length, m_data, m_length, U_FOLD_CASE_DEFAULT, &status);
+    if (U_FAILURE(status)) {
+        c->ref();
+        c->deref();
+        return copy();
+    }
     return c;
 }
 
-static UBreakIterator* getWordBreakIterator(const QChar* string, int length)
+static UBreakIterator* getWordBreakIterator(const UChar* string, int length)
 {
     // The locale is currently ignored when determining character cluster breaks.
     // This may change in the future, according to Deborah Goldsmith.
@@ -400,21 +460,20 @@ static UBreakIterator* getWordBreakIterator(const QChar* string, int length)
 
     status = U_ZERO_ERROR;
     ubrk_setText(iterator, reinterpret_cast<const ::UChar*>(string), length, &status);
-    if (status != U_ZERO_ERROR)
+    if (U_FAILURE(status))
         return 0;
 
     return iterator;
 }
 
-StringImpl* StringImpl::capitalize(QChar previous) const
+StringImpl* StringImpl::capitalize(UChar previous) const
 {
     StringImpl* capitalizedString = new StringImpl;
     if (!m_length)
         return capitalizedString;
     
-    QChar* stringWithPrevious = newQCharVector(m_length + 1);
+    UChar* stringWithPrevious = newUCharVector(m_length + 1);
     stringWithPrevious[0] = previous;
-    const char nonBreakingSpace = '\xa0';
     for (unsigned i = 1; i < m_length + 1; i++) {
         // Replace &nbsp with a real space since ICU no longer treats &nbsp as a word separator.
         if (m_data[i - 1] == nonBreakingSpace)
@@ -422,26 +481,26 @@ StringImpl* StringImpl::capitalize(QChar previous) const
         else
             stringWithPrevious[i] = m_data[i - 1];
     }
-    
+
     UBreakIterator* boundary = getWordBreakIterator(stringWithPrevious, m_length + 1);
     if (!boundary) {
-        deleteQCharVector(stringWithPrevious);
+        deleteUCharVector(stringWithPrevious);
         return capitalizedString;
     }
     
-    capitalizedString->m_data = newQCharVector(m_length);
+    capitalizedString->m_data = newUCharVector(m_length);
     capitalizedString->m_length = m_length;
     
     int32_t endOfWord;
     int32_t startOfWord = ubrk_first(boundary);
     for (endOfWord = ubrk_next(boundary); endOfWord != UBRK_DONE; startOfWord = endOfWord, endOfWord = ubrk_next(boundary)) {
         if (startOfWord != 0) // Ignore first char of previous string
-            capitalizedString->m_data[startOfWord - 1] = stringWithPrevious[startOfWord].upper();
+            capitalizedString->m_data[startOfWord - 1] = u_totitle(stringWithPrevious[startOfWord]);
         for (int i = startOfWord + 1; i < endOfWord; i++)
             capitalizedString->m_data[i - 1] = stringWithPrevious[i];
     }
     
-    deleteQCharVector(stringWithPrevious);
+    deleteUCharVector(stringWithPrevious);
     return capitalizedString;
 }
 
@@ -450,55 +509,48 @@ int StringImpl::toInt(bool* ok) const
     unsigned i = 0;
 
     // Allow leading spaces.
-    for (; i != m_length; ++i) {
-        if (!m_data[i].isSpace())
+    for (; i != m_length; ++i)
+        if (!QChar(m_data[i]).isSpace())
             break;
-    }
     
     // Allow sign.
     if (i != m_length && (m_data[i] == '+' || m_data[i] == '-'))
         ++i;
     
     // Allow digits.
-    for (; i != m_length; ++i) {
-        if (!m_data[i].isDigit())
+    for (; i != m_length; ++i)
+        if (!u_isdigit(m_data[i]))
             break;
-    }
     
-    return QConstString(m_data, i).string().toInt(ok);
+    return QConstString(reinterpret_cast<const QChar*>(m_data), i).string().toInt(ok);
 }
 
-static bool equal(const QChar* a, const char* b, int m_length)
+static bool equal(const UChar* a, const char* b, int length)
 {
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (*a != *b)
+    ASSERT(length >= 0);
+    while (length--) {
+        unsigned char bc = *b++;
+        if (*a++ != bc)
             return false;
-        a++; b++;
     }
     return true;
 }
 
-static bool equalCaseInsensitive(const QChar* a, const char* b, int m_length)
+static bool equalIgnoringCase(const UChar* a, const char* b, int length)
 {
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (tolower(a->unicode()) != tolower(*b))
+    ASSERT(length >= 0);
+    while (length--) {
+        unsigned char bc = *b++;
+        if (u_foldCase(*a++, U_FOLD_CASE_DEFAULT) != u_foldCase(bc, U_FOLD_CASE_DEFAULT))
             return false;
-        a++; b++;
     }
     return true;
 }
 
-static bool equalCaseInsensitive(const QChar* a, const QChar* b, int m_length)
+static inline bool equalIgnoringCase(const UChar* a, const UChar* b, int length)
 {
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (tolower(a->unicode()) != tolower(b->unicode()))
-            return false;
-        a++; b++;
-    }
-    return true;
+    ASSERT(length >= 0);
+    return u_memcasecmp(a, b, length, U_FOLD_CASE_DEFAULT) == 0;
 }
 
 // This function should be as fast as possible, every little bit helps.
@@ -523,17 +575,18 @@ int StringImpl::find(const char* chs, int index, bool caseSensitive) const
     const char* chsPlusOne = chs + 1;
     int chsLengthMinusOne = chsLength - 1;
     
-    const QChar* ptr = m_data + index - 1;
+    const UChar* ptr = m_data + index - 1;
     if (caseSensitive) {
-        QChar c = *chs;
+        UChar c = *chs;
         do {
             if (*++ptr == c && equal(ptr + 1, chsPlusOne, chsLengthMinusOne))
                 return m_length - chsLength - n + 1;
         } while (--n);
     } else {
-        int lc = tolower((unsigned char)*chs);
+        UChar lc = u_foldCase(*chs, U_FOLD_CASE_DEFAULT);
         do {
-            if (tolower((++ptr)->unicode()) == lc && equalCaseInsensitive(ptr + 1, chsPlusOne, chsLengthMinusOne))
+            if (u_foldCase(*++ptr, U_FOLD_CASE_DEFAULT) == lc
+                    && equalIgnoringCase(ptr + 1, chsPlusOne, chsLengthMinusOne))
                 return m_length - chsLength - n + 1;
         } while (--n);
     }
@@ -541,7 +594,7 @@ int StringImpl::find(const char* chs, int index, bool caseSensitive) const
     return -1;
 }
 
-int StringImpl::find(const QChar c, int start) const
+int StringImpl::find(const UChar c, int start) const
 {
     unsigned int index = start;
     if (index >= m_length )
@@ -565,8 +618,7 @@ int StringImpl::find(const StringImpl* str, int index, bool caseSensitive) const
       a part of this DeprecatedString.  Only if that matches, we call memcmp
       or ucstrnicmp.
 
-      The hash value of a string is the sum of the cells of its
-      QChars.
+      The hash value of a string is the sum of its characters.
     */
     ASSERT(str);
     if (index < 0)
@@ -579,38 +631,38 @@ int StringImpl::find(const StringImpl* str, int index, bool caseSensitive) const
     if (delta < 0)
         return -1;
 
-    const QChar* uthis = m_data + index;
-    const QChar* ustr = str->m_data;
+    const UChar* uthis = m_data + index;
+    const UChar* ustr = str->m_data;
     unsigned hthis = 0;
     unsigned hstr = 0;
     if (caseSensitive) {
         for (int i = 0; i < lstr; i++) {
-            hthis += uthis[i].unicode();
-            hstr += ustr[i].unicode();
+            hthis += uthis[i];
+            hstr += ustr[i];
         }
         int i = 0;
         while (1) {
-            if (hthis == hstr && memcmp(uthis + i, ustr, lstr * sizeof(QChar)) == 0)
+            if (hthis == hstr && memcmp(uthis + i, ustr, lstr * sizeof(UChar)) == 0)
                 return index + i;
             if (i == delta)
                 return -1;
-            hthis += uthis[i + lstr].unicode();
-            hthis -= uthis[i].unicode();
+            hthis += uthis[i + lstr];
+            hthis -= uthis[i];
             i++;
         }
     } else {
         for (int i = 0; i < lstr; i++ ) {
-            hthis += tolower(uthis[i].unicode());
-            hstr += tolower(ustr[i].unicode());
+            hthis += tolower(uthis[i]);
+            hstr += tolower(ustr[i]);
         }
         int i = 0;
         while (1) {
-            if (hthis == hstr && equalCaseInsensitive(uthis + i, ustr, lstr))
+            if (hthis == hstr && equalIgnoringCase(uthis + i, ustr, lstr))
                 return index + i;
             if (i == delta)
                 return -1;
-            hthis += tolower(uthis[i + lstr].unicode());
-            hthis -= tolower(uthis[i].unicode());
+            hthis += tolower(uthis[i + lstr]);
+            hthis -= tolower(uthis[i]);
             i++;
         }
     }
@@ -625,7 +677,7 @@ bool StringImpl::endsWith(const StringImpl* m_data, bool caseSensitive) const
     return false;
 }
 
-StringImpl* StringImpl::replace(QChar oldC, QChar newC)
+StringImpl* StringImpl::replace(UChar oldC, UChar newC)
 {
     if (oldC == newC)
         return this;
@@ -638,11 +690,11 @@ StringImpl* StringImpl::replace(QChar oldC, QChar newC)
 
     StringImpl* c = new StringImpl;
 
-    c->m_data = newQCharVector(m_length);
+    c->m_data = newUCharVector(m_length);
     c->m_length = m_length;
 
     for (i = 0; i != m_length; ++i) {
-        QChar ch = m_data[i];
+        UChar ch = m_data[i];
         if (ch == oldC)
             ch = newC;
         c->m_data[i] = ch;
@@ -659,7 +711,7 @@ StringImpl* StringImpl::replace(unsigned index, unsigned len, const StringImpl*
     return m_data;
 }
 
-StringImpl* StringImpl::replace(QChar pattern, const StringImpl* str)
+StringImpl* StringImpl::replace(UChar pattern, const StringImpl* str)
 {
     int slen = str ? str->length() : 0;
     int index = 0;
@@ -684,38 +736,18 @@ bool equal(const StringImpl* a, const char* b)
         return !a;
 
     unsigned length = a->length();
-    const QChar* as = a->unicode();
+    const UChar* as = a->characters();
     for (unsigned i = 0; i != length; ++i) {
-        char c = b[i];
-        if (!c)
+        unsigned char bc = b[i];
+        if (!bc)
             return false;
-        if (as[i] != c)
+        if (as[i] != bc)
             return false;
     }
 
     return !b[length];
 }
 
-bool equal(const char* a, const StringImpl* b)
-{
-    if (!a)
-        return !b;
-    if (!b)
-        return !a;
-
-    unsigned length = b->length();
-    const QChar* bs = b->unicode();
-    for (unsigned i = 0; i != length; ++i) {
-        char c = a[i];
-        if (!c)
-            return false;
-        if (c != bs[i])
-            return false;
-    }
-
-    return !a[length];
-}
-
 bool equalIgnoringCase(const StringImpl* a, const StringImpl* b)
 {
     return CaseInsensitiveHash::equal(a, b);
@@ -729,36 +761,29 @@ bool equalIgnoringCase(const StringImpl* a, const char* b)
         return !a;
 
     unsigned length = a->length();
-    const QChar* as = a->unicode();
+    const UChar* as = a->characters();
+
+    // Do a faster loop for the case where it's all ASCII.
+    UChar ored = 0;
+    bool equal = true;
     for (unsigned i = 0; i != length; ++i) {
-        char c = b[i];
-        if (!c)
-            return false;
-        if (as[i].lower() != QChar(c).lower())
+        unsigned char bc = b[i];
+        if (!bc)
             return false;
+        UChar ac = as[i];
+        ored |= ac;
+        equal &= tolower(ac) == tolower(bc);
     }
 
-    return !b[length];
-}
-
-bool equalIgnoringCase(const char* a, const StringImpl* b)
-{
-    if (!a)
-        return !b;
-    if (!b)
-        return !a;
-
-    unsigned length = b->length();
-    const QChar* bs = b->unicode();
-    for (unsigned i = 0; i != length; ++i) {
-        char c = a[i];
-        if (!c)
-            return false;
-        if (QChar(c).lower() != bs[i].lower())
-            return false;
+    if (ored & ~0x7F) {
+        equal = true;
+        for (unsigned i = 0; i != length; ++i) {
+            unsigned char bc = b[i];
+            equal &= u_foldCase(as[i], U_FOLD_CASE_DEFAULT) == u_foldCase(bc, U_FOLD_CASE_DEFAULT);
+        }
     }
 
-    return !a[length];
+    return equal && !b[length];
 }
 
 // Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's
@@ -767,7 +792,7 @@ const unsigned PHI = 0x9e3779b9U;
 
 // Paul Hsieh's SuperFastHash
 // http://www.azillionmonkeys.com/qed/hash.html
-unsigned StringImpl::computeHash(const QChar* m_data, unsigned len)
+unsigned StringImpl::computeHash(const UChar* m_data, unsigned len)
 {
     unsigned m_length = len;
     uint32_t hash = PHI;
@@ -778,8 +803,8 @@ unsigned StringImpl::computeHash(const QChar* m_data, unsigned len)
     
     // Main loop
     for (; m_length > 0; m_length--) {
-        hash += m_data[0].unicode();
-        tmp = (m_data[1].unicode() << 11) ^ hash;
+        hash += m_data[0];
+        tmp = (m_data[1] << 11) ^ hash;
         hash = (hash << 16) ^ tmp;
         m_data += 2;
         hash += hash >> 11;
@@ -787,7 +812,7 @@ unsigned StringImpl::computeHash(const QChar* m_data, unsigned len)
     
     // Handle end case
     if (rem) {
-        hash += m_data[0].unicode();
+        hash += m_data[0];
         hash ^= hash << 11;
         hash += hash >> 17;
     }
@@ -860,7 +885,7 @@ const char* StringImpl::ascii() const
     char* buffer = new char[m_length + 1];
     char* p = buffer;
     for (unsigned i = 0; i != m_length; ++i) {
-        unsigned short c = m_data[i].unicode();
+        UChar c = m_data[i];
         if (c >= 0x20 && c < 0x7F)
             *p++ = c;
         else
@@ -872,12 +897,12 @@ const char* StringImpl::ascii() const
 
 StringImpl::StringImpl(const Identifier& str)
 {
-    initWithQChar(reinterpret_cast<const QChar*>(str.data()), str.size());
+    init(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 StringImpl::StringImpl(const UString& str)
 {
-    initWithQChar(reinterpret_cast<const QChar*>(str.data()), str.size());
+    init(reinterpret_cast<const UChar*>(str.data()), str.size());
 }
 
 } // namespace WebCore
index 14cd72a..5d29fc1 100644 (file)
 #ifndef StringImpl_h
 #define StringImpl_h
 
-#include "DeprecatedString.h"
+#include "Shared.h"
+#include <kjs/identifier.h>
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
+#include <unicode/umachine.h>
 #include <limits.h>
 
 #if __OBJC__
 @class NSString;
 #endif
 
+class DeprecatedString;
+
 namespace WebCore {
 
 class AtomicString;
-struct QCharBufferTranslator;
+struct UCharBufferTranslator;
 struct CStringTranslator;
 struct Length;
 
-class StringImpl : public Shared<StringImpl>, Noncopyable
-{
+class StringImpl : public Shared<StringImpl>, Noncopyable {
 private:
     struct WithOneRef { };
     StringImpl(WithOneRef) : m_length(0), m_data(0), m_hash(0), m_inTable(false) { ref(); }
-    void initWithChar(const char*, unsigned len);
-    void initWithQChar(const QChar*, unsigned len);
+    void init(const char*, unsigned len);
+    void init(const UChar*, unsigned len);
 
 protected:
     StringImpl() : m_length(0), m_data(0), m_hash(0), m_inTable(false) { }
 public:
-    StringImpl(const DeprecatedString&);
+    StringImpl(const UChar*, unsigned len);
+    StringImpl(const char*, unsigned len);
+    StringImpl(const char*);
     StringImpl(const KJS::Identifier&);
     StringImpl(const KJS::UString&);
-    StringImpl(const QChar*, unsigned len);
-    StringImpl(const char*);
-    StringImpl(const char*, unsigned len);
     ~StringImpl();
 
-    const QChar* unicode() const { return m_data; }
+    const UChar* characters() const { return m_data; }
     unsigned length() const { return m_length; }
     
     unsigned hash() const { if (m_hash == 0) m_hash = computeHash(m_data, m_length); return m_hash; }
-    static unsigned computeHash(const QChar*, unsigned len);
+    static unsigned computeHash(const UChar*, unsigned len);
     static unsigned computeHash(const char*);
     
     void append(const StringImpl*);
     void insert(const StringImpl*, unsigned pos);
     void truncate(int len);
     void remove(unsigned pos, int len = 1);
-    
+
     StringImpl* split(unsigned pos);
     StringImpl* copy() const { return new StringImpl(m_data, m_length); }
 
     StringImpl* substring(unsigned pos, unsigned len = UINT_MAX);
 
-    const QChar& operator[] (int pos) const { return m_data[pos]; }
+    UChar operator[](int pos) const { return m_data[pos]; }
 
     Length toLength() const;
-    
+
     bool containsOnlyWhitespace() const;
     bool containsOnlyWhitespace(unsigned from, unsigned len) const;
-    
+
     // ignores trailing garbage, unlike DeprecatedString
     int toInt(bool* ok = 0) const;
 
@@ -91,18 +93,19 @@ public:
     bool isLower() const;
     StringImpl* lower() const;
     StringImpl* upper() const;
-    StringImpl* capitalize(QChar previous) const;
+    StringImpl* capitalize(UChar previousCharacter) const;
+    StringImpl* foldCase() const;
 
     int find(const char*, int index = 0, bool caseSensitive = true) const;
-    int find(QChar, int index = 0) const;
+    int find(UChar, int index = 0) const;
     int find(const StringImpl*, int index, bool caseSensitive = true) const;
 
     bool startsWith(const StringImpl* m_data, bool caseSensitive = true) const { return find(m_data, 0, caseSensitive) == 0; }
     bool endsWith(const StringImpl*, bool caseSensitive = true) const;
 
     // Does not modify the string.
-    StringImpl* replace(QChar, QChar);
-    StringImpl* replace(QChar a, const StringImpl* b);
+    StringImpl* replace(UChar, UChar);
+    StringImpl* replace(UChar, const StringImpl*);
     StringImpl* replace(unsigned index, unsigned len, const StringImpl*);
 
     static StringImpl* empty();
@@ -119,12 +122,14 @@ public:
     operator NSString*() const;
 #endif
 
+    StringImpl(const DeprecatedString&);
+
 private:
     unsigned m_length;
-    QChar* m_data;
+    UChar* m_data;
 
     friend class AtomicString;
-    friend struct QCharBufferTranslator;
+    friend struct UCharBufferTranslator;
     friend struct CStringTranslator;
     
     mutable unsigned m_hash;
@@ -133,11 +138,11 @@ private:
 
 bool equal(const StringImpl*, const StringImpl*);
 bool equal(const StringImpl*, const char*);
-bool equal(const char*, const StringImpl*);
+inline bool equal(const char* a, const StringImpl* b) { return equal(b, a); }
 
 bool equalIgnoringCase(const StringImpl*, const StringImpl*);
 bool equalIgnoringCase(const StringImpl*, const char*);
-bool equalIgnoringCase(const char*, const StringImpl*);
+inline bool equalIgnoringCase(const char* a, const StringImpl* b) { return equalIgnoringCase(b, a); }
 
 }
 
index b23b2ed..02e7bf6 100644 (file)
 #ifndef TextBoundaries_h
 #define TextBoundaries_h
 
-// FIXME: Change clients to use ICU and remove these functions.
+#include <unicode/umachine.h>
 
-class QChar;
+// FIXME: Change clients to use ICU and remove these functions.
 
 namespace WebCore {
 
-    void findWordBoundary(const QChar*, int len, int position, int *start, int *end);
-    int findNextWordFromIndex(const QChar*, int len, int position, bool forward);
+    void findWordBoundary(const UChar*, int len, int position, int *start, int *end);
+    int findNextWordFromIndex(const UChar*, int len, int position, bool forward);
 
-    void findSentenceBoundary(const QChar*, int len, int position, int *start, int *end);
-    int findNextSentenceFromIndex(const QChar*, int len, int position, bool forward);
+    void findSentenceBoundary(const UChar*, int len, int position, int *start, int *end);
+    int findNextSentenceFromIndex(const UChar*, int len, int position, bool forward);
 
 }
 
index e32b79c..aaf323b 100644 (file)
@@ -45,8 +45,7 @@ const char* TextEncoding::name() const
 {
     return charsetNameFromTextEncodingID(m_encodingID);
 }
-
-QChar TextEncoding::backslashAsCurrencySymbol() const
+UChar TextEncoding::backslashAsCurrencySymbol() const
 {
     if (m_flags & BackslashIsYen)
         return 0x00A5; // yen sign
@@ -128,7 +127,7 @@ DeprecatedCString TextEncoding::fromUnicode(const DeprecatedString &qcs, bool al
     // until then, we change the backslash into a yen sign.
     // Encoding will change the yen sign back into a backslash.
     DeprecatedString copy = qcs;
-    copy.replace(QChar('\\'), backslashAsCurrencySymbol());
+    copy.replace('\\', backslashAsCurrencySymbol());
 
     UErrorCode err = U_ZERO_ERROR;
     UConverter* conv = getConverter(encoding, &err);
index 48ba2cc..3703894 100644 (file)
@@ -80,7 +80,7 @@ namespace WebCore {
         bool usesVisualOrdering() const { return m_flags & VisualOrdering; }
         bool isJapanese() const { return m_flags & IsJapanese; }
         
-        QChar backslashAsCurrencySymbol() const;
+        UChar backslashAsCurrencySymbol() const;
         
         DeprecatedCString fromUnicode(const DeprecatedString&, bool allowEntities = false) const;
 
index 2e399bc..6d618d4 100644 (file)
@@ -54,7 +54,7 @@ NSString *FontFamily::getNSFamily() const
                 families = CFDictionaryCreateMutable(NULL, 0, &CFDictionaryFamilyKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
             m_CFFamily = (CFStringRef)CFDictionaryGetValue(families, m_family.impl());
             if (!m_CFFamily) {
-                m_CFFamily = CFStringCreateWithCharacters(0, (const UniChar *)m_family.unicode(), m_family.length());
+                m_CFFamily = CFStringCreateWithCharacters(0, m_family.characters(), m_family.length());
                 CFDictionarySetValue(families, m_family.impl(), m_CFFamily);
                 CFRelease(m_CFFamily);
             }
index 41c84ce..d44d88a 100644 (file)
@@ -39,6 +39,8 @@
 
 #import "IntRect.h"
 
+using namespace std;
+
 namespace WebCore {
 
 FontFallbackList::FontFallbackList()
@@ -102,11 +104,11 @@ const FontPlatformData& Font::platformFont() const
 }
 
 IntRect Font::selectionRectForText(const IntPoint& point, int h, int tabWidth, int xpos, 
-    const QChar* str, int slen, int pos, int l, int toAdd,
+    const UChar* str, int slen, int pos, int l, int toAdd,
     bool rtl, bool visuallyOrdered, int from, int to) const
 {
     assert(m_fontList);
-    int len = std::min(slen - pos, l);
+    int len = min(slen - pos, l);
 
     CREATE_FAMILY_ARRAY(fontDescription(), families);
 
@@ -116,7 +118,7 @@ IntRect Font::selectionRectForText(const IntPoint& point, int h, int tabWidth, i
         to = len;
 
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)(str+pos), len, from, to);    
+    WebCoreInitializeTextRun(&run, str + pos, len, from, to);
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
     style.rtl = rtl;
@@ -137,7 +139,7 @@ IntRect Font::selectionRectForText(const IntPoint& point, int h, int tabWidth, i
     return enclosingIntRect(m_fontList->primaryFont(fontDescription())->selectionRectForRun(&run, &style, &geometry));
 }
                      
-void Font::drawText(GraphicsContext* context, const IntPoint& point, int tabWidth, int xpos, const QChar* str, int len, int from, int to,
+void Font::drawText(GraphicsContext* context, const IntPoint& point, int tabWidth, int xpos, const UChar* str, int len, int from, int to,
                     int toAdd, TextDirection d, bool visuallyOrdered) const
 {
     // Avoid allocations, use stack array to pass font families.  Normally these
@@ -150,7 +152,7 @@ void Font::drawText(GraphicsContext* context, const IntPoint& point, int tabWidt
         to = len;
         
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)str, len, from, to);    
+    WebCoreInitializeTextRun(&run, str, len, from, to);    
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
     style.textColor = nsColor(context->pen().color());
@@ -170,7 +172,7 @@ void Font::drawText(GraphicsContext* context, const IntPoint& point, int tabWidt
     m_fontList->primaryFont(fontDescription())->drawRun(&run, &style, &geometry);
 }
 
-void Font::drawHighlightForText(GraphicsContext* context, const IntPoint& point, int h, int tabWidth, int xpos, const QChar* str,
+void Font::drawHighlightForText(GraphicsContext* context, const IntPoint& point, int h, int tabWidth, int xpos, const UChar* str,
                                 int len, int from, int to, int toAdd,
                                 TextDirection d, bool visuallyOrdered, const Color& backgroundColor) const
 {
@@ -184,7 +186,7 @@ void Font::drawHighlightForText(GraphicsContext* context, const IntPoint& point,
         to = len;
         
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)str, len, from, to);    
+    WebCoreInitializeTextRun(&run, str, len, from, to);    
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
     style.textColor = nsColor(context->pen().color());
@@ -222,13 +224,13 @@ int Font::misspellingLineThickness(GraphicsContext* context) const
     return m_fontList->primaryFont(fontDescription())->misspellingLineThickness();
 }
 
-float Font::floatWidth(const QChar* uchars, int slen, int pos, int len, int tabWidth, int xpos, bool runRounding) const
+float Font::floatWidth(const UChar* uchars, int slen, int pos, int len, int tabWidth, int xpos, bool runRounding) const
 {
     assert(m_fontList);
     CREATE_FAMILY_ARRAY(fontDescription(), families);
 
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)uchars, slen, pos, pos+len);
+    WebCoreInitializeTextRun(&run, uchars, slen, pos, pos + len);
     
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
@@ -243,13 +245,13 @@ float Font::floatWidth(const QChar* uchars, int slen, int pos, int len, int tabW
     return m_fontList->primaryFont(fontDescription())->floatWidthForRun(&run, &style);
 }
 
-int Font::checkSelectionPoint(const QChar* s, int slen, int pos, int len, int toAdd, int tabWidth, int xpos, int x, TextDirection d, bool visuallyOrdered, bool includePartialGlyphs) const
+int Font::checkSelectionPoint(const UChar* s, int slen, int pos, int len, int toAdd, int tabWidth, int xpos, int x, TextDirection d, bool visuallyOrdered, bool includePartialGlyphs) const
 {
     assert(m_fontList);
     CREATE_FAMILY_ARRAY(fontDescription(), families);
     
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)(s+pos), std::min(slen - pos, len), 0, len);
+    WebCoreInitializeTextRun(&run, s + pos, min(slen - pos, len), 0, len);
     
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
index d2bf322..6d45e17 100644 (file)
@@ -31,9 +31,9 @@
 
 namespace WebCore {
 
-void findWordBoundary(const QChar* chars, int len, int position, int* start, int* end)
+void findWordBoundary(const UChar* chars, int len, int position, int* start, int* end)
 {
-    NSString* string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(reinterpret_cast<const unichar*>(chars))
+    NSString* string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(chars)
         length:len freeWhenDone:NO];
     NSAttributedString* attr = [[NSAttributedString alloc] initWithString:string];
     NSRange range = [attr doubleClickAtIndex:(position >= len) ? len - 1 : position];
@@ -43,9 +43,9 @@ void findWordBoundary(const QChar* chars, int len, int position, int* start, int
     *end = range.location + range.length;
 }
 
-int findNextWordFromIndex(const QChar* chars, int len, int position, bool forward)
+int findNextWordFromIndex(const UChar* chars, int len, int position, bool forward)
 {   
-    NSString* string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(reinterpret_cast<const unichar*>(chars))
+    NSString* string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(chars)
         length:len freeWhenDone:NO];
     NSAttributedString* attr = [[NSAttributedString alloc] initWithString:string];
     int result = [attr nextWordFromIndex:position forward:forward];
@@ -99,14 +99,13 @@ static char* currentTextBreakLocaleID()
     return localeString;
 }
 
-void findSentenceBoundary(const QChar* chars, int len, int position, int* start, int* end)
+void findSentenceBoundary(const UChar* chars, int len, int position, int* start, int* end)
 {
     int startPos = 0;
     int endPos = 0;
 
     UErrorCode status = U_ZERO_ERROR;
-    UBreakIterator* boundary = ubrk_open(UBRK_SENTENCE, currentTextBreakLocaleID(),
-        const_cast<unichar*>(reinterpret_cast<const unichar*>(chars)), len, &status);
+    UBreakIterator* boundary = ubrk_open(UBRK_SENTENCE, currentTextBreakLocaleID(), chars, len, &status);
     if (boundary && U_SUCCESS(status)) {
         startPos = ubrk_preceding(boundary, position);
         if (startPos == UBRK_DONE) {
@@ -123,13 +122,12 @@ void findSentenceBoundary(const QChar* chars, int len, int position, int* start,
     *end = endPos;
 }
 
-int findNextSentenceFromIndex(const QChar* chars, int len, int position, bool forward)
+int findNextSentenceFromIndex(const UChar* chars, int len, int position, bool forward)
 {
     int pos = 0;
     
     UErrorCode status = U_ZERO_ERROR;
-    UBreakIterator* boundary = ubrk_open(UBRK_SENTENCE, currentTextBreakLocaleID(),
-        const_cast<unichar*>(reinterpret_cast<const unichar*>(chars)), len, &status);
+    UBreakIterator* boundary = ubrk_open(UBRK_SENTENCE, currentTextBreakLocaleID(), chars, len, &status);
     if (boundary && U_SUCCESS(status)) {
         if (forward) {
             pos = ubrk_following(boundary, position);
index 83584cc..1450ae8 100644 (file)
@@ -51,7 +51,7 @@ DeprecatedCString TextEncoding::fromUnicode(const DeprecatedString &qcs, bool al
     // FIXME: Since there's no "force ASCII range" mode in CFString, we change the backslash into a yen sign.
     // Encoding will change the yen sign back into a backslash.
     DeprecatedString copy = qcs;
-    copy.replace(QChar('\\'), backslashAsCurrencySymbol());
+    copy.replace('\\', backslashAsCurrencySymbol());
     CFStringRef cfs = copy.getCFString();
     CFMutableStringRef cfms = CFStringCreateMutableCopy(0, 0, cfs); // in rare cases, normalization can make the string longer, thus no limit on its length
     CFStringNormalize(cfms, kCFStringNormalizationFormC);
index 2ae422a..0d5443d 100644 (file)
@@ -118,7 +118,7 @@ IntRect InlineTextBox::selectionRect(int tx, int ty, int startPos, int endPos)
     const Font *f = textObj->font(m_firstLine);
 
     IntRect r = f->selectionRectForText(IntPoint(tx + m_x, ty + selTop), selHeight, textObj->tabWidth(), textPos(), 
-                                        textObj->str->unicode(), textObj->str->length(), m_start, m_len,
+                                        textObj->str->characters(), textObj->str->length(), m_start, m_len,
                                         m_toAdd, m_reversed, m_dirOverride, sPos, ePos);
     if (r.x() > tx + m_x + m_width)
         r.setWidth(0);
@@ -333,7 +333,7 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
         if (m_truncation != cNoTruncation)
             endPoint = m_truncation - m_start;
         i.p->drawText(IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                      textObject()->string()->unicode(), textObject()->string()->length(), m_start, endPoint,
+                      textObject()->string()->characters(), textObject()->string()->length(), m_start, endPoint,
                       m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
     } else {
         int sPos, ePos;
@@ -342,16 +342,16 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
             // paint only the text that is not selected
             if (sPos >= ePos)
                 i.p->drawText(IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                              textObject()->string()->unicode(), textObject()->string()->length(), m_start, m_len,
+                              textObject()->string()->characters(), textObject()->string()->length(), m_start, m_len,
                               m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
             else {
                 if (sPos - 1 >= 0)
                     i.p->drawText(IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                                  textObject()->string()->unicode(), textObject()->string()->length(), m_start, m_len,
+                                  textObject()->string()->characters(), textObject()->string()->length(), m_start, m_len,
                                   m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered(), 0, sPos);
                 if (ePos < m_start + m_len)
                     i.p->drawText(IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                                  textObject()->string()->unicode(), textObject()->string()->length(), m_start, m_len,
+                                  textObject()->string()->characters(), textObject()->string()->length(), m_start, m_len,
                                   m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered(), ePos, -1);
             }
         }
@@ -366,7 +366,7 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
                                selectionTextShadow->blur,
                                selectionTextShadow->color);
             i.p->drawText(IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                          textObject()->string()->unicode(), textObject()->string()->length(), m_start, m_len,
+                          textObject()->string()->characters(), textObject()->string()->length(), m_start, m_len,
                           m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered(), sPos, ePos);
             if (selectionTextShadow)
                 i.p->clearShadow();
@@ -451,7 +451,7 @@ void InlineTextBox::paintSelection(GraphicsContext* p, int tx, int ty, RenderSty
     int h = r->selectionHeight();
     p->addClip(IntRect(m_x + tx, y + ty, m_width, h));
     p->drawHighlightForText(IntPoint(m_x + tx, y + ty), h, textObject()->tabWidth(), textPos(), 
-                            textObject()->str->unicode(), textObject()->str->length(), m_start, m_len,
+                            textObject()->str->characters(), textObject()->str->length(), m_start, m_len,
                             m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), sPos, ePos, c);
     p->restore();
 }
@@ -475,7 +475,7 @@ void InlineTextBox::paintMarkedTextBackground(GraphicsContext* p, int tx, int ty
     int y = r->selectionTop();
     int h = r->selectionHeight();
     p->drawHighlightForText(IntPoint(m_x + tx, y + ty), h, textObject()->tabWidth(), textPos(),
-                            textObject()->str->unicode(), textObject()->str->length(), m_start, m_len,
+                            textObject()->str->characters(), textObject()->str->length(), m_start, m_len,
                             m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), sPos, ePos, c);
     p->restore();
 }
@@ -574,7 +574,7 @@ void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, int _tx, int _ty,
     int ePos = min(marker.endOffset - m_start, (unsigned)m_len);
     
     pt->drawHighlightForText(IntPoint(m_x + _tx, y + _ty), h, textObject()->tabWidth(), textPos(), 
-                             textObject()->str->unicode(), textObject()->str->length(), m_start, m_len,
+                             textObject()->str->characters(), textObject()->str->length(), m_start, m_len,
                              m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), sPos, ePos, yellow);
     pt->restore();
 }
@@ -688,7 +688,7 @@ int InlineTextBox::offsetForPosition(int _x, bool includePartialGlyphs) const
     RenderText* text = static_cast<RenderText*>(m_object);
     RenderStyle *style = text->style(m_firstLine);
     const Font* f = &style->font();
-    return f->checkSelectionPoint(text->str->unicode(), text->str->length(), m_start, m_len,
+    return f->checkSelectionPoint(text->str->characters(), text->str->length(), m_start, m_len,
         m_toAdd, text->tabWidth(), textPos(), _x - m_x,
         m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), includePartialGlyphs);
 }
@@ -703,7 +703,7 @@ int InlineTextBox::positionForOffset(int offset) const
     int from = m_reversed ? offset - m_start : 0;
     int to = m_reversed ? m_len : offset - m_start;
     // FIXME: Do we need to add rightBearing here?
-    return f->selectionRectForText(IntPoint(m_x, 0), 0, text->tabWidth(), textPos(), text->str->unicode(), text->str->length(), m_start, m_len,
+    return f->selectionRectForText(IntPoint(m_x, 0), 0, text->tabWidth(), textPos(), text->str->characters(), text->str->length(), m_start, m_len,
         m_toAdd, m_reversed, m_dirOverride, from, to).right();
 }
 
index 78610b6..5720301 100644 (file)
@@ -2831,8 +2831,8 @@ static inline void stripTrailingSpace(int& inlineMax, int& inlineMin,
         // Collapse away the trailing space at the end of a block.
         RenderText* t = static_cast<RenderText *>(trailingSpaceChild);
         const Font *f = t->font(false);  // FIXME: Why are we ignoring first-line?
-        QChar space[1]; space[0] = ' ';
-        int spaceWidth = f->width(space, 1);
+        const UChar space = ' ';
+        int spaceWidth = f->width(&space, 1);
         inlineMax -= spaceWidth;
         if (inlineMin > inlineMax)
             inlineMin = inlineMax;
@@ -3397,7 +3397,7 @@ void RenderBlock::updateFirstLetter()
             unsigned int length = 0;
             
             // account for leading spaces and punctuation
-            while (length < oldText->length() && ((*oldText)[length].isSpace() || (*oldText)[length].isPunct()))
+            while (length < oldText->length() && (QChar((*oldText)[length]).isSpace() || u_ispunct((*oldText)[length])))
                 length++;
             
             // account for first letter
index c2691df..318d1ca 100644 (file)
@@ -728,10 +728,12 @@ void RenderFlexibleBox::layoutVerticalBox(bool relayoutChildren)
                 
                 RenderBlock* blockChild = static_cast<RenderBlock*>(child);
                 int lineCount = blockChild->lineCount();
-                if (lineCount <= numVisibleLines) continue;
+                if (lineCount <= numVisibleLines)
+                    continue;
                 
                 int newHeight = blockChild->heightForLineCount(numVisibleLines);
-                if (newHeight == child->height()) continue;
+                if (newHeight == child->height())
+                    continue;
                 
                 child->setChildNeedsLayout(true);
                 child->setOverrideSize(newHeight);
@@ -741,25 +743,32 @@ void RenderFlexibleBox::layoutVerticalBox(bool relayoutChildren)
                 child->setOverrideSize(-1);
                 
                 // FIXME: For now don't support RTL.
-                if (style()->direction() != LTR) continue;
+                if (style()->direction() != LTR)
+                    continue;
                 
                 // Get the last line
                 RootInlineBox* lastLine = blockChild->lineAtIndex(lineCount-1);
-                if (!lastLine) continue;
+                if (!lastLine)
+                    continue;
                 
                 // See if the last item is an anchor
                 InlineBox* anchorBox = lastLine->lastChild();
-                if (!anchorBox) continue;
-                if (!anchorBox->object()->element()) continue;
-                if (!anchorBox->object()->element()->isLink()) continue;
+                if (!anchorBox)
+                    continue;
+                if (!anchorBox->object()->element())
+                    continue;
+                if (!anchorBox->object()->element()->isLink())
+                    continue;
                 
                 RootInlineBox* lastVisibleLine = blockChild->lineAtIndex(numVisibleLines-1);
-                if (!lastVisibleLine) continue;
+                if (!lastVisibleLine)
+                    continue;
 
-                const unsigned short ellipsisAndSpace[2] = { 0x2026, ' ' };
+                const UChar ellipsisAndSpace[2] = { 0x2026, ' ' };
                 static AtomicString ellipsisAndSpaceStr(ellipsisAndSpace, 2);
+
                 const Font& font = style(numVisibleLines == 1)->font();
-                int ellipsisAndSpaceWidth = font.width(const_cast<QChar*>(ellipsisAndSpaceStr.unicode()), 2, 0, 2, 0, 0);
+                int ellipsisAndSpaceWidth = font.width(ellipsisAndSpace, 2, 0, 2, 0, 0);
 
                 // Get ellipsis width + " " + anchor width
                 int totalWidth = ellipsisAndSpaceWidth + anchorBox->width();
@@ -769,8 +778,10 @@ void RenderFlexibleBox::layoutVerticalBox(bool relayoutChildren)
                 RenderBlock* srcBlock = static_cast<RenderBlock*>(lastLine->object());
                 
                 // FIXME: Directions of src/destBlock could be different from our direction and from one another.
-                if (srcBlock->style()->direction() != LTR) continue;
-                if (destBlock->style()->direction() != LTR) continue;
+                if (srcBlock->style()->direction() != LTR)
+                    continue;
+                if (destBlock->style()->direction() != LTR)
+                    continue;
 
                 int blockEdge = destBlock->rightOffset(lastVisibleLine->yPos());
                 if (!lastVisibleLine->canAccommodateEllipsis(true, blockEdge, 
index d86e01c..0a01656 100644 (file)
@@ -104,7 +104,7 @@ void RenderImage::imageChanged(CachedImage* o)
         // we have an alt and the user meant it (its not a text we invented)
         if (!m_altText.isEmpty()) {
             const Font& font = style()->font();
-            iw = max(iw, min(font.width(m_altText.deprecatedString()), 1024));
+            iw = max(iw, min(font.width(m_altText.characters(), m_altText.length()), 1024));
             ih = max(ih, min(font.height(), 256));
         }
 
@@ -237,7 +237,7 @@ void RenderImage::paint(PaintInfo& i, int _tx, int _ty)
             
             if (!m_altText.isEmpty()) {
                 DeprecatedString text = m_altText.deprecatedString();
-                text.replace(QChar('\\'), backslashAsCurrencySymbol());
+                text.replace('\\', backslashAsCurrencySymbol());
                 p->setFont(style()->font());
                 p->setPen(style()->color());
                 int ax = _tx + leftBorder + leftPad;
@@ -247,12 +247,12 @@ void RenderImage::paint(PaintInfo& i, int _tx, int _ty)
                 
                 // Only draw the alt text if it'll fit within the content box,
                 // and only if it fits above the error image.
-                int textWidth = font.width(text);
+                int textWidth = font.width(reinterpret_cast<const UChar*>(text.unicode()), text.length());
                 if (errorPictureDrawn) {
                     if (usableWidth >= textWidth && font.height() <= imageY)
-                        p->drawText(IntPoint(ax, ay + ascent), 0, text);
+                        p->drawText(IntPoint(ax, ay + ascent), text);
                 } else if (usableWidth >= textWidth && cHeight >= font.height())
-                    p->drawText(IntPoint(ax, ay + ascent), 0, text);
+                    p->drawText(IntPoint(ax, ay + ascent), text);
             }
         }
     }
index 26f3af1..da70464 100644 (file)
@@ -2496,7 +2496,7 @@ bool RenderObject::usesLineWidth() const
     return (avoidsFloats() && (style()->width().isAuto() || isHR() || (style()->htmlHacks() && !isTable())));
 }
 
-QChar RenderObject::backslashAsCurrencySymbol() const
+UChar RenderObject::backslashAsCurrencySymbol() const
 {
     if (Node *node = element())
         if (Decoder *decoder = node->document()->decoder())
index 2628afe..91146da 100644 (file)
@@ -844,7 +844,7 @@ public:
     virtual bool isStretchingChildren() const { return false; }
 
     // Convenience, to avoid repeating the code to dig down to get this.
-    QChar backslashAsCurrencySymbol() const;
+    UChar backslashAsCurrencySymbol() const;
 
     virtual int caretMinOffset() const;
     virtual int caretMaxOffset() const;
index a4e99b7..0a3b8c3 100644 (file)
@@ -58,7 +58,7 @@ UBreakIterator* characterBreakIterator(const StringImpl* i)
         return 0;
 
     status = U_ZERO_ERROR;
-    ubrk_setText(iterator, reinterpret_cast<const UChar*>(i->unicode()), i->length(), &status);
+    ubrk_setText(iterator, reinterpret_cast<const UChar*>(i->characters()), i->length(), &status);
     if (status != U_ZERO_ERROR)
         return 0;
 
@@ -101,7 +101,7 @@ RenderText::RenderText(WebCore::Node* node, StringImpl *_str)
     setRenderText();
     if (str)
         str = str->replace('\\', backslashAsCurrencySymbol());
-    KHTMLAssert(!str || !str->length() || str->unicode());
+    KHTMLAssert(!str || !str->length() || str->characters());
 }
 
 void RenderText::setStyle(RenderStyle *_style)