Changeset 14273 in webkit

Timestamp:

May 9, 2006 9:59:57 PM (18 years ago)

Author:

darin

Message:

LayoutTests:

• 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.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/css/case-transform-expected.txt (added)
• LayoutTests/fast/css/case-transform.html (added)
• WebCore/ChangeLog (modified) (2 diffs)
• WebCore/bindings/js/JSXMLSerializer.cpp (modified) (1 diff)
• WebCore/bindings/js/kjs_css.cpp (modified) (1 diff)
• WebCore/bindings/js/kjs_navigator.cpp (modified) (2 diffs)
• WebCore/bindings/js/kjs_proxy.cpp (modified) (8 diffs)
• WebCore/bindings/js/kjs_window.cpp (modified) (1 diff)
• WebCore/bindings/objc/DOMInternal.mm (modified) (2 diffs)
• WebCore/bridge/mac/FrameMac.mm (modified) (15 diffs)
• WebCore/bridge/mac/WebCoreFrameBridge.mm (modified) (2 diffs)
• WebCore/css/CSSGrammar.y (modified) (8 diffs)
• WebCore/css/css_valueimpl.cpp (modified) (3 diffs)
• WebCore/css/css_valueimpl.h (modified) (1 diff)
• WebCore/css/csshelper.cpp (modified) (3 diffs)
• WebCore/css/cssparser.cpp (modified) (11 diffs)
• WebCore/css/cssparser.h (modified) (4 diffs)
• WebCore/css/cssstyleselector.cpp (modified) (1 diff)
• WebCore/dom/CharacterData.cpp (modified) (1 diff)
• WebCore/dom/Document.cpp (modified) (6 diffs)
• WebCore/dom/Document.h (modified) (1 diff)
• WebCore/dom/NamedMappedAttrMap.cpp (modified) (2 diffs)
• WebCore/dom/Position.cpp (modified) (4 diffs)
• WebCore/dom/StyledElement.cpp (modified) (3 diffs)
• WebCore/dom/dom2_eventsimpl.cpp (modified) (1 diff)
• WebCore/dom/xml_tokenizer.h (modified) (1 diff)
• WebCore/editing/HTMLInterchange.cpp (modified) (1 diff)
• WebCore/editing/InsertTextCommand.cpp (modified) (1 diff)
• WebCore/editing/RebalanceWhitespaceCommand.cpp (modified) (1 diff)
• WebCore/editing/ReplaceSelectionCommand.cpp (modified) (1 diff)
• WebCore/editing/TextIterator.cpp (modified) (20 diffs)
• WebCore/editing/TextIterator.h (modified) (12 diffs)
• WebCore/editing/VisiblePosition.cpp (modified) (1 diff)
• WebCore/editing/VisiblePosition.h (modified) (1 diff)
• WebCore/editing/markup.cpp (modified) (1 diff)
• WebCore/editing/visible_units.cpp (modified) (16 diffs)
• WebCore/html/HTMLInputElement.cpp (modified) (1 diff)
• WebCore/html/HTMLParser.cpp (modified) (2 diffs)
• WebCore/html/HTMLTokenizer.cpp (modified) (38 diffs)
• WebCore/html/HTMLTokenizer.h (modified) (8 diffs)
• WebCore/html/html_inlineimpl.cpp (modified) (3 diffs)
• WebCore/kwq/KWQLoader.mm (modified) (2 diffs)
• WebCore/kwq/KWQTextStream.cpp (modified) (1 diff)
• WebCore/kwq/WebCoreAXObject.mm (modified) (3 diffs)
• WebCore/loader/Cache.cpp (modified) (2 diffs)
• WebCore/loader/Cache.h (modified) (3 diffs)
• WebCore/loader/CachedObject.h (modified) (1 diff)
• WebCore/page/Frame.cpp (modified) (3 diffs)
• WebCore/page/Frame.h (modified) (1 diff)
• WebCore/platform/AtomicString.cpp (modified) (10 diffs)
• WebCore/platform/AtomicString.h (modified) (5 diffs)
• WebCore/platform/Color.cpp (modified) (1 diff)
• WebCore/platform/DeprecatedString.h (modified) (4 diffs)
• WebCore/platform/Font.cpp (modified) (1 diff)
• WebCore/platform/Font.h (modified) (2 diffs)
• WebCore/platform/GraphicsContext.cpp (modified) (3 diffs)
• WebCore/platform/GraphicsContext.h (modified) (3 diffs)
• WebCore/platform/PlatformString.h (modified) (8 diffs)
• WebCore/platform/SegmentedString.cpp (modified) (4 diffs)
• WebCore/platform/SegmentedString.h (modified) (10 diffs)
• WebCore/platform/StreamingTextDecoder.cpp (modified) (14 diffs)
• WebCore/platform/StreamingTextDecoder.h (modified) (1 diff)
• WebCore/platform/String.cpp (modified) (17 diffs)
• WebCore/platform/StringHash.h (modified) (8 diffs)
• WebCore/platform/StringImpl.cpp (modified) (47 diffs)
• WebCore/platform/StringImpl.h (modified) (8 diffs)
• WebCore/platform/TextBoundaries.h (modified) (1 diff)
• WebCore/platform/TextEncoding.cpp (modified) (2 diffs)
• WebCore/platform/TextEncoding.h (modified) (1 diff)
• WebCore/platform/mac/FontFamilyMac.mm (modified) (1 diff)
• WebCore/platform/mac/FontMac.mm (modified) (11 diffs)
• WebCore/platform/mac/TextBoundaries.mm (modified) (5 diffs)
• WebCore/platform/mac/TextEncodingMac.cpp (modified) (1 diff)
• WebCore/rendering/InlineTextBox.cpp (modified) (9 diffs)
• WebCore/rendering/RenderBlock.cpp (modified) (2 diffs)
• WebCore/rendering/RenderFlexibleBox.cpp (modified) (3 diffs)
• WebCore/rendering/RenderImage.cpp (modified) (3 diffs)
• WebCore/rendering/RenderObject.cpp (modified) (1 diff)
• WebCore/rendering/RenderObject.h (modified) (1 diff)
• WebCore/rendering/RenderText.cpp (modified) (16 diffs)
• WebCore/rendering/RenderText.h (modified) (2 diffs)
• WebCore/rendering/RenderTextField.cpp (modified) (2 diffs)
• WebCore/rendering/RenderTreeAsText.cpp (modified) (1 diff)
• WebCore/rendering/bidi.cpp (modified) (45 diffs)
• WebCore/rendering/bidi.h (modified) (5 diffs)
• WebCore/rendering/break_lines.cpp (modified) (2 diffs)
• WebCore/rendering/break_lines.h (modified) (1 diff)
• WebCore/rendering/render_form.cpp (modified) (6 diffs)
• WebCore/rendering/render_line.cpp (modified) (2 diffs)
• WebCore/rendering/render_list.cpp (modified) (7 diffs)
• WebCore/rendering/render_style.cpp (modified) (4 diffs)
• WebCore/rendering/render_style.h (modified) (1 diff)
• WebCore/xml/XSLStyleSheet.cpp (modified) (2 diffs)
• WebCore/xml/xmlhttprequest.cpp (modified) (4 diffs)
• WebCore/xpath/impl/XPathExpressionNode.cpp (modified) (7 diffs)
• WebCore/xpath/impl/XPathExpressionNode.h (modified) (4 diffs)
• WebCore/xpath/impl/XPathFunctions.cpp (modified) (13 diffs)
• WebCore/xpath/impl/XPathGrammar.y (modified) (1 diff)
• WebCore/xpath/impl/XPathParser.cpp (modified) (16 diffs)
• WebCore/xpath/impl/XPathParser.h (modified) (5 diffs)
• WebCore/xpath/impl/XPathPath.cpp (modified) (2 diffs)
• WebCore/xpath/impl/XPathPredicate.cpp (modified) (2 diffs)
• WebCore/xpath/impl/XPathValue.cpp (modified) (8 diffs)
• WebCore/xpath/impl/XPathValue.h (modified) (2 diffs)
• WebCore/xpath/impl/XPathVariableReference.cpp (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+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>
 

trunk/WebCore/ChangeLog

@@ +1 @@
+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>
 
@@ -655 +1091 @@
         * 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.

trunk/WebCore/bindings/js/JSXMLSerializer.cpp

@@ -23 +23 @@
 #include "JSXMLSerializer.lut.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "kjs_dom.h"

trunk/WebCore/bindings/js/kjs_css.cpp

@@ -49 +49 @@
     int i = prop.length();
     while (--i) {
-        char c = prop[i].latin1();
+        ::UChar c = prop[i].unicode();
         if (c >= 'A' && c <= 'Z')
             prop.insert(i, '-');

trunk/WebCore/bindings/js/kjs_navigator.cpp

@@ -159 +159 @@
     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");
@@ -185 +176 @@
     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);

trunk/WebCore/bindings/js/kjs_proxy.cpp

@@ -35 +35 @@
 namespace WebCore {
 
-KJSProxy::KJSProxy(Frame *frame)
+KJSProxy::KJSProxy(Frame* frame)
 {
     m_script = 0;
@@ -49 +49 @@
 }
 
-JSValue* KJSProxy::evaluate(const String& filename, int baseLine, const String& str, Node *n) 
+JSValue* KJSProxy::evaluate(const String& filename, int baseLine, const String& str, Node* n) 
 {
   // evaluate code. Returns the JS return value or 0
@@ -66 +66 @@
 
   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)
@@ -92 +92 @@
 }
 
-EventListener* KJSProxy::createHTMLEventHandler(const String& functionName, const String& code, Node *node)
+EventListener* KJSProxy::createHTMLEventHandler(const String& functionName, const String& code, Node* node)
 {
     initScriptIfNeeded();
@@ -100 +100 @@
 
 #if SVG_SUPPORT
-EventListener* KJSProxy::createSVGEventHandler(const String& functionName, const String& code, Node *node)
+EventListener* KJSProxy::createSVGEventHandler(const String& functionName, const String& code, Node* node)
 {
     initScriptIfNeeded();
@@ -108 +108 @@
 #endif
 
-void KJSProxy::finishedWithEvent(Event *event)
+void KJSProxy::finishedWithEvent(Event* event)
 {
   // This is called when the DOM implementation has finished with a particular event. This
@@ -117 +117 @@
 }
 
-ScriptInterpreter *KJSProxy::interpreter()
+ScriptInterpreter* KJSProxy::interpreter()
 {
   initScriptIfNeeded();
@@ -128 +128 @@
 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();
 }

trunk/WebCore/bindings/js/kjs_window.cpp

@@ -1379 +1379 @@
 
 // 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';

trunk/WebCore/bindings/objc/DOMInternal.mm

@@ -101 +101 @@
 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(NSString* str)
 {
     if (!str)
@@ -113 +113 @@
         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);
     }
 }

trunk/WebCore/bridge/mac/FrameMac.mm

@@ -79 +79 @@
 
 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 {
@@ -90 +92 @@
 using namespace HTMLNames;
 
-NSEvent *FrameMac::_currentEvent = nil;
+NSEvent* FrameMac::_currentEvent = nil;
 
 static NSMutableDictionary* createNSDictionary(const HashMap<String, String>& map)
@@ -115 +117 @@
 
     SEL selector = NULL;
-    switch (key[0U].unicode()) {
+    switch (key[0U]) {
     case NSUpArrowFunctionKey:
         selector = @selector(moveUp:); break;
@@ -633 +635 @@
 {
     String text = title;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
@@ -643 +645 @@
 {
     String text = status;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
     
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
@@ -731 +733 @@
     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];
@@ -1227 +1229 @@
 {
     String text = message;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     [_bridge runJavaScriptAlertPanelWithMessage:text];
@@ -1236 +1238 @@
 {
     String text = message;
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
@@ -1248 +1250 @@
 {
     String promptText = prompt;
-    promptText.replace(QChar('\\'), backslashAsCurrencySymbol());
+    promptText.replace('\\', backslashAsCurrencySymbol());
     String defaultValueText = defaultValue;
-    defaultValueText.replace(QChar('\\'), backslashAsCurrencySymbol());
+    defaultValueText.replace('\\', backslashAsCurrencySymbol());
 
     bool ok;
@@ -1261 +1263 @@
     if (ok) {
         result = String(returnedText);
-        result.replace(backslashAsCurrencySymbol(), QChar('\\'));
+        result.replace(backslashAsCurrencySymbol(), '\\');
     }
 
@@ -2284 +2286 @@
                         [pendingStyledSpace release];
                         pendingStyledSpace = nil;
-                        addedSpace = str[runEnd-1].direction() == QChar::DirWS;
+                        addedSpace = u_charDirection(str[runEnd - 1].unicode()) == U_WHITE_SPACE_NEUTRAL;
                     }
                     else {
@@ -2319 +2321 @@
                                     [pendingStyledSpace release];
                                     pendingStyledSpace = nil;
-                                    addedSpace = str[runEnd-1].direction() == QChar::DirWS;
+                                    addedSpace = u_charDirection(str[runEnd - 1].unicode()) == U_WHITE_SPACE_NEUTRAL;
                                     start = -1;
                                 }
@@ -2329 +2331 @@
                 }
                 
-                text.replace(QChar('\\'), renderer->backslashAsCurrencySymbol());
+                text.replace('\\', renderer->backslashAsCurrencySymbol());
     
                 if (text.length() > 0 || needSpace) {
@@ -3106 +3108 @@
     
     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.
@@ -3403 +3405 @@
 
     String text = event->result();
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
 
     return [_bridge runBeforeUnloadConfirmPanelWithMessage:text];

trunk/WebCore/bridge/mac/WebCoreFrameBridge.mm

@@ -752 +752 @@
 {
     String text = m_frame->selectedText();
-    text.replace(QChar('\\'), m_frame->backslashAsCurrencySymbol());
+    text.replace('\\', m_frame->backslashAsCurrencySymbol());
     return [[(NSString*)text copy] autorelease];
 }
@@ -759 +759 @@
 {
     String text = plainText([range _range]);
-    text.replace(QChar('\\'), m_frame->backslashAsCurrencySymbol());
+    text.replace('\\', m_frame->backslashAsCurrencySymbol());
     return [[(NSString*)text copy] autorelease];
 }

trunk/WebCore/css/CSSGrammar.y

@@ -56 +56 @@
 namespace WebCore {
 
-int getPropertyID(const char *tagStr, int len)
+int getPropertyID(const char* tagStr, int len)
 {
     DeprecatedString prop;
@@ -79 +79 @@
         }
     }
-    
-    const struct props *propsPtr = findProp(tagStr, len);
+
+    const struct props* propsPtr = findProp(tagStr, len);
     if (!propsPtr)
         return 0;
@@ -89 +89 @@
 }
 
-static inline int getValueID(const char *tagStr, int len)
+static inline int getValueID(const char* tagStr, int len)
 {
     DeprecatedString prop;
@@ -370 +370 @@
 
 maybe_ns_prefix:
-/* empty */ { $$.string = 0; }
+/* empty */ { $$.characters = 0; }
 | IDENT WHITESPACE { $$ = $1; }
 ;
@@ -390 +390 @@
     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 {
@@ -530 +530 @@
 
 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; }
 ;
@@ -601 +601 @@
     }
     | '*' {
-        static unsigned short star = '*';
-        $$.string = &star;
+        static UChar star = '*';
+        $$.characters = &star;
         $$.length = 1;
     }
@@ -842 +842 @@
 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
     }

trunk/WebCore/css/css_valueimpl.cpp

@@ -47 +47 @@
 
 // Defined in CSSGrammar.y, but not in any header, so just declare it here for now.
-int getPropertyID(const char *str, int len);
-
-static int propertyID(const String &s)
+int getPropertyID(const char* str, int len);
+
+static int propertyID(const String& s)
 {
     char buffer[maxCSSPropertyNameLength];
@@ -58 +58 @@
 
     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
@@ -86 +86 @@
     s.replace('\\', "\\\\");
     s.replace('\'', "\\'");
-    return '\'' + s + '\'';
+    return "'" + s + "'";
 }
 

trunk/WebCore/css/css_valueimpl.h

@@ -27 +27 @@
 #include "css_base.h"
 #include "DeprecatedPtrList.h"
+#include "DeprecatedString.h"
 #include "DeprecatedValueList.h"
 #include <wtf/PassRefPtr.h>

trunk/WebCore/css/csshelper.cpp

@@ -39 +39 @@
     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] == ')') {
@@ -56 +56 @@
     }
 
-    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;
 
@@ -68 +68 @@
     }
 
-    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);
 }
 

trunk/WebCore/css/cssparser.cpp

@@ -117 +117 @@
 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]);
 }
 
@@ -125 +133 @@
     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();
@@ -2571 +2579 @@
 #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
@@ -2594 +2603 @@
     case UNICODERANGE:
     case FUNCTION:
-        yylval->string.string = t;
+        yylval->string.characters = t;
         yylval->string.length = length;
         break;
@@ -2652 +2661 @@
 }
 
-unsigned short *CSSParser::text(int *length)
-{
-    unsigned short *start = yytext;
+UChar* CSSParser::text(int *length)
+{
+    UChar* start = yytext;
     int l = yyleng;
     switch(yyTok) {
@@ -2693 +2702 @@
 
     // 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') ||
@@ -2728 +2737 @@
         if (escape) {
             // add escaped char
-            int uc = 0;
+            unsigned uc = 0;
             escape++;
             while (escape < current) {
@@ -2738 +2747 @@
             if (uc > 0xffff)
                 uc = 0xfffd;
-            *(out++) = (unsigned short)uc;
+            *out++ = uc;
             escape = 0;
             if (*current == ' ' ||
@@ -2751 +2760 @@
             continue;
         }
-        *(out++) = *current;
+        *out++ = *current;
     }
     if (escape) {
         // add escaped char
-        int uc = 0;
+        unsigned uc = 0;
         escape++;
         while (escape < start+l) {
@@ -2765 +2774 @@
         if (uc > 0xffff)
             uc = 0xfffd;
-        *(out++) = (unsigned short)uc;
+        *out++ = uc;
     }
     
@@ -2882 +2891 @@
     clearProperties();
     return rule;
+}
+
+DeprecatedString deprecatedString(const ParseString& ps)
+{
+    return DeprecatedString(reinterpret_cast<const QChar*>(ps.characters), ps.length);
 }
 

trunk/WebCore/css/cssparser.h

@@ -46 +46 @@
 
     struct ParseString {
-        unsigned short* string;
+        UChar* characters;
         int length;
         
@@ -70 +70 @@
     };
 
-    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);
     }
 
@@ -202 +200 @@
         int lex(void* yylval);
         int token() { return yyTok; }
-        unsigned short* text(int* length);
+        UChar* text(int* length);
         int lex();
         
@@ -212 +210 @@
         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;

trunk/WebCore/css/cssstyleselector.cpp

@@ -557 +557 @@
     }
     
-    QConstString cu(attr.unicode(), attr.length());
+    QConstString cu(reinterpret_cast<const QChar*>(attr.characters()), attr.length());
     DeprecatedString u = cu.string();
     if (!u.contains("://")) {

trunk/WebCore/dom/CharacterData.cpp

@@ -45 +45 @@
     : 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();
 }

trunk/WebCore/dom/Document.cpp

@@ -2393 +2393 @@
 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();
 
@@ -2426 +2426 @@
     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;
@@ -2490 +2490 @@
 }
 
-QChar Document::backslashAsCurrencySymbol() const
+UChar Document::backslashAsCurrencySymbol() const
 {
     if (!m_decoder)
@@ -3099 +3099 @@
 
 #if XPATH_SUPPORT
+
 PassRefPtr<XPathExpression> Document::createExpression(const String& expression,
                                                        XPathNSResolver* resolver,
@@ -3105 +3106 @@
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->createExpression(expression, resolver, ec);
 }
 
-PassRefPtr<XPathNSResolver> Document::createNSResolver(Node *nodeResolver)
+PassRefPtr<XPathNSResolver> Document::createNSResolver(Node* nodeResolver)
 {
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->createNSResolver(nodeResolver);
 }
@@ -3126 +3125 @@
     if (!m_xpathEvaluator)
         m_xpathEvaluator = new XPathEvaluator;
-    
     return m_xpathEvaluator->evaluate(expression, contextNode, resolver, type, result, ec);
 }

trunk/WebCore/dom/Document.h

@@ -706 +706 @@
     Decoder* decoder() const { return m_decoder.get(); }
 
-    QChar backslashAsCurrencySymbol() const;
+    UChar backslashAsCurrencySymbol() const;
 
 #if __APPLE__

trunk/WebCore/dom/NamedMappedAttrMap.cpp

@@ -77 +77 @@
 }
 
-inline static bool isClassWhitespace(QChar c)
+inline static bool isClassWhitespace(UChar c)
 {
     return c == ' ' || c == '\r' || c == '\n' || c == '\t';
@@ -94 +94 @@
     AtomicStringList* curr = 0;
     
-    const QChar* str = classAttr.unicode();
+    const UChar* str = classAttr.characters();
     int length = classAttr.length();
     int sPos = 0;

trunk/WebCore/dom/Position.cpp

@@ -40 +40 @@
 
 using namespace HTMLNames;
+
+const UChar nonBreakingSpace = 0xa0;
 
 static Node *nextRenderedEditable(Node *node)
@@ -627 +629 @@
     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;
     }
@@ -641 +643 @@
 
     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();
@@ -656 +658 @@
     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;
     }

trunk/WebCore/dom/StyledElement.cpp

@@ -102 +102 @@
 }
 
-inline static bool isClassWhitespace(QChar c)
+inline static bool isClassWhitespace(UChar c)
 {
     return c == ' ' || c == '\r' || c == '\n' || c == '\t';
@@ -296 +296 @@
         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;
@@ -359 +359 @@
                 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) {

trunk/WebCore/dom/dom2_eventsimpl.cpp

@@ -514 +514 @@
     if (text.length() != 1)
         return 0;
-    return text[0].unicode();
+    return text[0];
 }
 

trunk/WebCore/dom/xml_tokenizer.h

@@ -63 +63 @@
 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

trunk/WebCore/editing/HTMLInterchange.cpp

@@ -62 +62 @@
     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;

trunk/WebCore/editing/InsertTextCommand.cpp

@@ -79 +79 @@
 
     return pos;
-}
-
-static inline bool isNBSP(const QChar &c)
-{
-    return c.unicode() == 0xa0;
 }
 

trunk/WebCore/editing/RebalanceWhitespaceCommand.cpp

@@ -39 +39 @@
 }
 
-static inline bool isWhitespace(const QChar &c)
+static inline bool isWhitespace(UChar c)
 {
-    return c.unicode() == 0xa0 || isCollapsibleWhitespace(c);
+    return c == 0xa0 || isCollapsibleWhitespace(c);
 }
 

trunk/WebCore/editing/ReplaceSelectionCommand.cpp

@@ -620 +620 @@
         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);
         }

trunk/WebCore/editing/TextIterator.cpp

@@ -44 +44 @@
 using namespace HTMLNames;
 
-const unsigned short nonBreakingSpace = 0xA0;
+const UChar nonBreakingSpace = 0xA0;
 
 // Buffer that knows how to compare with a search target.
@@ -55 +55 @@
 
     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;
@@ -66 +66 @@
     bool m_isCaseSensitive;
 
-    QChar *m_buffer;
-    QChar *m_cursor;
+    UChar* m_buffer;
+    UChar* m_cursor;
     bool m_bufferFull;
 
@@ -74 +74 @@
 };
 
-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)
 {
 }
@@ -230 +230 @@
         m_positionStartOffset = runStart;
         m_positionEndOffset = runEnd;
-        m_textCharacters = str.unicode() + runStart;
+        m_textCharacters = str.characters() + runStart;
         m_textLength = runEnd - runStart;
 
@@ -272 +272 @@
         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;
@@ -305 +305 @@
                 m_positionStartOffset = runStart;
                 m_positionEndOffset = subrunEnd;
-                m_textCharacters = str.unicode() + runStart;
+                m_textCharacters = str.characters() + runStart;
                 m_textLength = subrunEnd - runStart;
 
@@ -506 +506 @@
 }
 
-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()
@@ -690 +690 @@
     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];
@@ -735 +735 @@
 }
 
-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;
@@ -844 +844 @@
     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);
@@ -895 +895 @@
     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;
 
@@ -906 +906 @@
         // 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;
@@ -913 +913 @@
         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);
@@ -926 +926 @@
     if (!m_buffer.isEmpty())
         return m_buffer.length();
-    else if (m_previousText)
+    if (m_previousText)
         return m_previousLength;
-    else
-        return m_textIterator.length();
-}
-
-const QChar *WordAwareIterator::characters() const
+    return m_textIterator.length();
+}
+
+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();
 }
 
@@ -948 +946 @@
 
     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;
@@ -972 +970 @@
 // 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;
@@ -981 +979 @@
     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);
         }
     }
@@ -1009 +1007 @@
     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;
 }
 
@@ -1095 +1093 @@
 }
 
-DeprecatedString plainText(const Range *r)
+DeprecatedString plainText(const Range* r)
 {
     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;
 }

trunk/WebCore/editing/TextIterator.h

@@ -1 +1 @@
 /*
- * 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
@@ -36 +36 @@
 // 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':
@@ -66 +66 @@
     
     int length() const { return m_textLength; }
-    const QChar *characters() const { return m_textCharacters; }
+    const UChar* characters() const { return m_textCharacters; }
     
     PassRefPtr<Range> range() const;
@@ -79 +79 @@
     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
@@ -98 +98 @@
     mutable int m_positionStartOffset;
     mutable int m_positionEndOffset;
-    const QChar *m_textCharacters;
+    const UChar* m_textCharacters;
     int m_textLength;
     
@@ -109 +109 @@
     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)
@@ -132 +132 @@
     
     int length() const { return m_textLength; }
-    const QChar *characters() const { return m_textCharacters; }
+    const UChar* characters() const { return m_textCharacters; }
     
     PassRefPtr<Range> range() const;
@@ -141 +141 @@
     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;
+    Node* m_node;
     int m_offset;
     bool m_handledNode;
@@ -152 +152 @@
     
     // End of the range.
-    Node *m_startNode;
+    Node* m_startNode;
     int m_startOffset;
     
     // The current text and its position, in the form to be returned from the iterator.
-    Node *m_positionNode;
+    Node* m_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;
+    Node* m_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;
 };
 
@@ -183 +183 @@
     
     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);
     
@@ -208 +208 @@
     
     int length() const;
-    const QChar *characters() const;
+    const UChar* characters() const;
     
     // Range of the text we're currently returning
@@ -215 +215 @@
 private:
     // text from the previous chunk from the textIterator
-    const QChar *m_previousText;
+    const UChar* m_previousText;
     int m_previousLength;
 

trunk/WebCore/editing/VisiblePosition.cpp

@@ -199 +199 @@
 }
 
-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];
 }

trunk/WebCore/editing/VisiblePosition.h

@@ -67 +67 @@
     bool isLastInBlock() const;
 
-    QChar characterAfter() const;
+    UChar characterAfter() const;
     
     void debugPosition(const char* msg = "") const;

trunk/WebCore/editing/markup.cpp

@@ -55 +55 @@
     unsigned len = in.length();
     for (unsigned i = 0; i < len; ++i) {
-        switch (in[i].latin1()) {
+        switch (in[i].unicode()) {
             case '&':
                 s += "&amp;";

trunk/WebCore/editing/visible_units.cpp

@@ -39 +39 @@
 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();
@@ -73 +73 @@
     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;
@@ -93 +93 @@
         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)
@@ -116 +116 @@
 }
 
-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();
@@ -144 +144 @@
         // 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;
@@ -165 +165 @@
         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;
@@ -185 +185 @@
 // ---------
 
-static unsigned startWordBoundary(const QChar *characters, unsigned length)
+static unsigned startWordBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
@@ -207 +207 @@
 }
 
-static unsigned endWordBoundary(const QChar *characters, unsigned length)
+static unsigned endWordBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
@@ -235 +235 @@
 }
 
-static unsigned previousWordPositionBoundary(const QChar *characters, unsigned length)
+static unsigned previousWordPositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextWordFromIndex(characters, length, length, false);
@@ -245 +245 @@
 }
 
-static unsigned nextWordPositionBoundary(const QChar *characters, unsigned length)
+static unsigned nextWordPositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextWordFromIndex(characters, length, 0, true);
@@ -491 +491 @@
 // ---------
 
-static unsigned startSentenceBoundary(const QChar *characters, unsigned length)
+static unsigned startSentenceBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
@@ -503 +503 @@
 }
 
-static unsigned endSentenceBoundary(const QChar *characters, unsigned length)
+static unsigned endSentenceBoundary(const UChar* characters, unsigned length)
 {
     int start, end;
@@ -515 +515 @@
 }
 
-static unsigned previousSentencePositionBoundary(const QChar *characters, unsigned length)
+static unsigned previousSentencePositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextSentenceFromIndex(characters, length, length, false);
@@ -525 +525 @@
 }
 
-static unsigned nextSentencePositionBoundary(const QChar *characters, unsigned length)
+static unsigned nextSentencePositionBoundary(const UChar* characters, unsigned length)
 {
     return findNextSentenceFromIndex(characters, length, 0, true);
@@ -564 +564 @@
         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;
@@ -624 +624 @@
             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)

trunk/WebCore/html/HTMLInputElement.cpp

@@ -1443 +1443 @@
         int newLen = numCharactersInGraphemeClusters(s, maxLen);
         for (int i = 0; i < newLen; ++i)
-            if ((*s)[i].unicode() < ' ') {
+            if ((*s)[i] < ' ') {
                 newLen = i;
                 break;

trunk/WebCore/html/HTMLParser.cpp

@@ -49 +49 @@
 
 using namespace HTMLNames;
+
+const UChar nonBreakingSpace = 0xa0;
 
 /**
@@ -474 +476 @@
                     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())

trunk/WebCore/html/HTMLTokenizer.cpp

@@ -66 +66 @@
 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.
@@ -85 +82 @@
 // 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
@@ -92 +89 @@
 };
 
-static inline QChar fixUpChar(QChar c)
-{
-    unsigned short code = c.unicode();
-    if ((code & ~0x1F) != 0x0080)
+static inline UChar fixUpChar(UChar c)
+{
+    if ((c & ~0x1F) != 0x0080)
         return c;
-    return windowsLatin1ExtensionArray[code - 0x80];
-}
-
-inline bool tagMatch(const char *s1, const QChar *s2, unsigned length)
+    return windowsLatin1ExtensionArray[c - 0x80];
+}
+
+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;
@@ -112 +108 @@
 }
 
-void Token::addAttribute(Document* doc, const AtomicString& attrName, const AtomicString& v)
-{
-    Attribute* a = 0;
+inline void Token::addAttribute(Document* doc, const AtomicString& attrName, const AtomicString& v)
+{
     if (!attrName.isEmpty() && attrName != "/") {
-        a = new MappedAttribute(attrName, v);
+        Attribute* a = new MappedAttribute(attrName, v);
         if (!attrs)
             attrs = new NamedMappedAttrMap(0);
@@ -167 +162 @@
     }
     
-    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;
@@ -190 +183 @@
     reset();
     size = 254;
-    buffer = KHTML_ALLOC_QCHAR_VEC( 255 );
+    buffer = static_cast<UChar*>(fastMalloc(sizeof(UChar) * 254));
     dest = buffer;
     tquote = NoQuote;
@@ -262 +255 @@
     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);
@@ -268 +261 @@
             continue;
         }
-        if ( scriptCodeResync && !tquote && ( ch == '>' ) ) {
+        if (scriptCodeResync && !tquote && ch == '>') {
             ++src;
             scriptCodeSize = scriptCodeResync-1;
@@ -303 +296 @@
         }
         // 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 )) {
@@ -310 +303 @@
             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'))
@@ -320 +313 @@
         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;
@@ -371 +363 @@
     }
     state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
-    DeprecatedString exScript( buffer, dest-buffer );
+    DeprecatedString exScript(reinterpret_cast<QChar*>(buffer), dest - buffer);
     processToken();
     currToken.tagName = scriptTag.localName();
@@ -507 +499 @@
     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
@@ -556 +544 @@
     while (!src.isEmpty()) {
         scriptCode[scriptCodeSize++] = *src;
-        if (src->unicode() == '>' &&
+        if (*src == '>' &&
             scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
             ++src;
@@ -570 +558 @@
 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);
@@ -601 +585 @@
 {
     while (!src.isEmpty()) {
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
 
         if (state.skipLF()) {
@@ -626 +610 @@
 
 
-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)
@@ -637 +621 @@
     while(!src.isEmpty())
     {
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
         switch(state.entityState()) {
         case NoEntity:
@@ -655 +639 @@
 
         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;
@@ -690 +674 @@
             int ll = min(src.length(), 9-cBufferPos);
             while(ll--) {
-                cc = src->unicode();
+                cc = *src;
 
                 if (!(cc >= '0' && cc <= '9')) {
@@ -709 +693 @@
             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'))) {
@@ -738 +721 @@
         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();
@@ -748 +729 @@
                 } 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 {
@@ -780 +759 @@
     {
         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:
@@ -822 +794 @@
                           if (!src.isEmpty())
                               // cuts off high bits, which is okay
-                              cBuffer[cBufferPos++] = src->unicode();
+                              cBuffer[cBufferPos++] = *src;
                         }
                         else
@@ -831 +803 @@
                     }
                     // cuts off high bits, which is okay
-                    cBuffer[cBufferPos++] = src->unicode();
+                    cBuffer[cBufferPos++] = *src;
                     ++src;
                     break;
@@ -842 +814 @@
             unsigned int ll = min(src.length(), CBUFLEN-cBufferPos);
             while(ll--) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar <= ' ' || curchar == '>' ) {
                     finish = true;
@@ -894 +866 @@
 #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 != '"') {
@@ -915 +887 @@
             int ll = min(src.length(), CBUFLEN-cBufferPos);
             while(ll--) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if (curchar <= '>' && (curchar >= '=' || curchar <= ' ')) {
                     cBuffer[cBufferPos] = '\0';
@@ -953 +925 @@
 #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 != '"') {
@@ -975 +947 @@
         case SearchValue:
             while(!src.isEmpty()) {
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar > ' ') {
                     if(( curchar == '\'' || curchar == '\"' )) {
@@ -996 +968 @@
                 checkBuffer();
 
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if (curchar == '>' && attrName.isEmpty()) {
                     // Handle a case like <img '>.  Just go ahead and be willing
@@ -1052 +1024 @@
             while(!src.isEmpty()) {
                 checkBuffer();
-                unsigned short curchar = src->unicode();
+                UChar curchar = *src;
                 if(curchar <= '>' && !src.escaped()) {
                     // parse Entities
@@ -1341 +1313 @@
         checkBuffer();
 
-        unsigned short cc = src->unicode();
+        UChar cc = *src;
 
         bool wasSkipLF = state.skipLF();
@@ -1506 +1478 @@
             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;
     }
@@ -1533 +1504 @@
         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
-        }
-        KHTML_DELETE_QCHAR_VEC(scriptCode);
+            pos = QConstString(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize).string().find('>');
+            food.setUnicode(reinterpret_cast<QChar*>(scriptCode) + pos + 1, scriptCodeSize - pos - 1); // deep copy
+        }
+        fastFree(scriptCode);
         scriptCode = 0;
         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
@@ -1627 +1598 @@
 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;
-}
-
-void HTMLTokenizer::notifyFinished(CachedObject */*finishedObj*/)
+    int newSize = max(scriptCodeMaxSize * 2, scriptCodeMaxSize + len);
+    scriptCode = static_cast<UChar*>(fastRealloc(scriptCode, newSize * sizeof(UChar)));
+    scriptCodeMaxSize = newSize;
+}
+
+void HTMLTokenizer::notifyFinished(CachedObject*)
 {
 #if INSTRUMENT_LAYOUT_SCHEDULING
@@ -1729 +1699 @@
 }
 
-unsigned short decodeNamedEntity(const char* name)
+UChar decodeNamedEntity(const char* name)
 {
     const Entity* e = findEntity(name, strlen(name));

trunk/WebCore/html/HTMLTokenizer.h

@@ -83 +83 @@
     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);
@@ -107 +107 @@
     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.
@@ -129 +129 @@
     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();
@@ -138 +138 @@
     // Internal buffers
     ///////////////////
-    QChar *buffer;
-    QChar *dest;
+    UChar* buffer;
+    UChar* dest;
 
     Token currToken;
@@ -149 +149 @@
     //////////////////
     // 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?
@@ -274 +269 @@
     
     // Used to store the code of a srcipting sequence
-    QChar *scriptCode;
+    UChar* scriptCode;
     // Size of the script sequenze stored in @ref #scriptCode
     int scriptCodeSize;
@@ -283 +278 @@
 
     // 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;
@@ -340 +335 @@
 void parseHTMLDocumentFragment(const String&, DocumentFragment*);
 
-unsigned short decodeNamedEntity(const char*);
+UChar decodeNamedEntity(const char*);
 
 }

trunk/WebCore/html/html_inlineimpl.cpp

@@ -407 +407 @@
 // 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;
     
@@ -418 +418 @@
     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;
@@ -427 +427 @@
     
     // 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;
     

trunk/WebCore/kwq/KWQLoader.mm

@@ -27 +27 @@
 #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 "KWQResourceLoader.h"
+#import "Logging.h"
+#import "Request.h"
 #import "TransferJob.h"
-#import "Logging.h"
-#import "KWQResourceLoader.h"
-#import "FrameMac.h"
-#import "Request.h"
 #import "WebCoreFrameBridge.h"
 #import "loader.h"
-#import "loader.h"
-
 #import <Foundation/NSURLResponse.h>
 
@@ -216 +214 @@
 }
 
-#define LOCAL_STRING_BUFFER_SIZE 1024
-
-bool KWQIsResponseURLEqualToURL(NSURLResponse *response, const WebCore::String &m_url)
-{
-    unichar _buffer[LOCAL_STRING_BUFFER_SIZE];
-    unichar *urlStringCharacters;
-    
+bool KWQIsResponseURLEqualToURL(NSURLResponse *response, const WebCore::String& m_url)
+{
     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));
 }
 

trunk/WebCore/kwq/KWQTextStream.cpp

@@ -27 +27 @@
 #include "KWQTextStream.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "Logging.h"

trunk/WebCore/kwq/WebCoreAXObject.mm

@@ -1269 +1269 @@
 }
 
-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
@@ -1279 +1279 @@
     
     // 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
@@ -1351 +1351 @@
         // 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)));
         }
         

trunk/WebCore/loader/Cache.cpp

@@ -228 +228 @@
 }
 
-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)
 {
@@ -285 +277 @@
     updateCacheStatus(dl, url, o);
     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));
 }
 

trunk/WebCore/loader/Cache.h

@@ -49 +49 @@
     /**
      * Provides a cache/loader for objects needed for displaying the html page.
-     * At the moment these are stylesheets, scripts and images
      */
     class Cache {
@@ -55 +54 @@
     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
@@ -126 +102 @@
         /**
          * 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();

trunk/WebCore/loader/CachedObject.h

@@ -28 +28 @@
 #define KHTML_CachedObject_h
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include "KWQKIOGlobal.h"

trunk/WebCore/page/Frame.cpp

@@ -83 +83 @@
 
 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 {
@@ -97 +105 @@
     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);
@@ -3255 +3263 @@
 }
 
-QChar Frame::backslashAsCurrencySymbol() const
+UChar Frame::backslashAsCurrencySymbol() const
 {
     Document *doc = document();

trunk/WebCore/page/Frame.h

@@ -713 +713 @@
   // Convenience, to avoid repeating the code to dig down to get this.
 
-  QChar backslashAsCurrencySymbol() const;
+  UChar backslashAsCurrencySymbol() const;
 
   DeprecatedValueList<MarkedTextUnderline> markedTextUnderlines() const;  

trunk/WebCore/platform/AtomicString.cpp

@@ -24 +24 @@
 
 #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"
@@ -34 +35 @@
 #include <wtf/HashSet.h>
 
-using namespace KJS;
+using KJS::Identifier;
+using KJS::UString;
 
 namespace WebCore {
-   
+
 static HashSet<StringImpl*>* stringTable;
 
@@ -50 +52 @@
     {
         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])
@@ -69 +71 @@
 { 
     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); 
@@ -87 +89 @@
 }
 
-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();
@@ -105 +107 @@
             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);
         
@@ -121 +123 @@
     }
 
-    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);
@@ -131 +133 @@
 };
 
-StringImpl* AtomicString::add(const QChar* s, int length)
+StringImpl* AtomicString::add(const UChar* s, int length)
 {
     if (!s)
@@ -139 +141 @@
         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;
 }
 
@@ -164 +166 @@
 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();
 }
 

trunk/WebCore/platform/AtomicString.h

@@ -34 +34 @@
     
     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)) { }
@@ -44 +41 @@
     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;
@@ -54 +50 @@
     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); }
@@ -87 +83 @@
 #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&);
@@ -116 +115 @@
 
 // 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;

trunk/WebCore/platform/Color.cpp

@@ -27 +27 @@
 #include "Color.h"
 
+#include "DeprecatedString.h"
 #include "PlatformString.h"
 #include <wtf/Assertions.h>

trunk/WebCore/platform/DeprecatedString.h

@@ -51 +51 @@
 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);
@@ -68 +62 @@
     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:
@@ -119 +106 @@
     // 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);
 }
 
@@ -167 +119 @@
     // FIXME: If fast enough, we should just call u_toupper directly.
     return c <= 0x7F ? toupper(c) : u_toupper(c);
-}
-
-inline QChar::Direction QChar::direction() const
-{
-    return static_cast<Direction>(u_charDirection(c));
 }
 

trunk/WebCore/platform/Font.cpp

@@ -77 +77 @@
 }
 
-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.

trunk/WebCore/platform/Font.h

@@ -74 +74 @@
 
     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;
@@ -83 +83 @@
     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(); }

trunk/WebCore/platform/GraphicsContext.cpp

@@ -27 +27 @@
 #include "GraphicsContext.h"
 
+#include "DeprecatedString.h"
 #include "Font.h"
 
@@ -193 +194 @@
 
 // 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)
-{
-    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);
-}
-
-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, const DeprecatedString& str)
+{
+    if (paintingDisabled())
+        return;
+
+    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 UChar* str, int slen, int pos, int len, int toAdd,
                                TextDirection d, bool visuallyOrdered, int from, int to)
 {
@@ -220 +216 @@
 }
 
-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)
 {

trunk/WebCore/platform/GraphicsContext.h

@@ -33 +33 @@
 #include "TextDirection.h"
 #include <wtf/Noncopyable.h>
+#include <unicode/umachine.h>
 
 #if __APPLE__
@@ -44 +45 @@
 
 class DeprecatedString;
-class QChar;
 
 namespace WebCore {
@@ -107 +107 @@
         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);

trunk/WebCore/platform/PlatformString.h

@@ -39 +39 @@
  */
 
-// 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&);
@@ -56 +52 @@
     operator KJS::UString() const;
 
-    String& operator +=(const String&);
+    unsigned length() const;
+    const UChar* characters() const;
 
-    void insert(const String&, unsigned pos);
-
-    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
@@ -78 +73 @@
         { 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);
@@ -97 +94 @@
     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);
@@ -108 +105 @@
     static String sprintf(const char *, ...)
 #if __GNUC__
-    __attribute__ ((format (printf, 1, 2)))
+        __attribute__ ((format (printf, 1, 2)))
 #endif
-    ;
+        ;
 
     int toInt(bool* ok = 0) const;
@@ -138 +135 @@
 #endif
 
+    String(const DeprecatedString&);
+    DeprecatedString deprecatedString() const;
+    
 private:
     RefPtr<StringImpl> m_impl;
@@ -145 +145 @@
 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()); }
@@ -163 +161 @@
 
 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); }

trunk/WebCore/platform/SegmentedString.cpp

@@ -57 +57 @@
 {
     unsigned length = m_currentString.m_length;
-    if (m_pushedChar1.unicode()) {
+    if (m_pushedChar1) {
         ++length;
-        if (m_pushedChar2.unicode())
+        if (m_pushedChar2)
             ++length;
     }
@@ -119 +119 @@
             append(*i);
     }
-    m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
+    m_currentChar = m_pushedChar1 ? &m_pushedChar1 : m_currentString.m_current;
 }
 
@@ -133 +133 @@
     }
     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;
 }
 
@@ -151 +151 @@
 {
     DeprecatedString result;
-    if (m_pushedChar1.unicode()) {
+    if (m_pushedChar1) {
         result.append(m_pushedChar1);
-        if (m_pushedChar2.unicode())
+        if (m_pushedChar2)
             result.append(m_pushedChar2);
     }

trunk/WebCore/platform/SegmentedString.h

@@ -2 +2 @@
     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
@@ -19 +19 @@
     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"
@@ -40 +38 @@
     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(DeprecatedString& str) const {
+        if (reinterpret_cast<const UChar*>(m_string.unicode()) == m_current) {
             if (str.isEmpty())
                 str = m_string;
@@ -54 +52 @@
                 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);
         }
     }
@@ -60 +58 @@
     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&);
 
@@ -77 +82 @@
     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;
         }
@@ -91 +96 @@
 
     void advance() {
-        if (m_pushedChar1.unicode()) {
+        if (m_pushedChar1) {
             m_pushedChar1 = m_pushedChar2;
             m_pushedChar2 = 0;
@@ -99 +104 @@
                 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; }
@@ -110 +115 @@
 
     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:
@@ -118 +123 @@
 
     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;

trunk/WebCore/platform/StreamingTextDecoder.cpp

@@ -45 +45 @@
 static const UChar replacementCharacter = 0xFFFD;
 static const UChar BOM = 0xFEFF;
-static const int ConversionBufferSize = 16384;
+static const size_t ConversionBufferSize = 16384;
     
 static UConverter* cachedConverterICU;
@@ -60 +60 @@
 }
 
-DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char *s, int length)
+DeprecatedString StreamingTextDecoder::convertUTF16(const unsigned char* s, int length)
 {
     ASSERT(m_numBufferedBytes == 0 || m_numBufferedBytes == 1);
 
-    const unsigned char *p = s;
-    unsigned len = length;
+    const unsigned char* p = s;
+    size_t len = length;
     
     DeprecatedString result("");
@@ -80 +80 @@
 
         if (c)
-            result.append(reinterpret_cast<QChar *>(&c), 1);
+            result.append(reinterpret_cast<QChar*>(&c), 1);
 
         m_numBufferedBytes = 0;
@@ -89 +89 @@
     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) {
@@ -95 +95 @@
                 UChar c = p[0] | (p[1] << 8);
                 p += 2;
-                if (c && c != BOM)
+                if (c != BOM)
                     buffer[bufferLength++] = c;
             }
@@ -102 +102 @@
                 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;
     }
@@ -119 +119 @@
 }
 
+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)
 {
@@ -127 +156 @@
 }
 
-UErrorCode StreamingTextDecoder::createICUConverter()
+void StreamingTextDecoder::createICUConverter()
 {
     TextEncoding encoding = effectiveEncoding(m_encoding);
@@ -142 +171 @@
         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;
-        }
-    }
-    
-    return U_ZERO_ERROR;
+#endif
+    }
 }
 
@@ -163 +189 @@
 }
 
-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);
@@ -171 +197 @@
         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);
-}
-
-DeprecatedString StreamingTextDecoder::convertUsingICU(const unsigned char *chs, int len, bool flush)
+        s.append(reinterpret_cast<const QChar*>(&characters[start]), characterCount - start);
+}
+
+DeprecatedString StreamingTextDecoder::convertUsingICU(const unsigned char* chs, 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("");
@@ -191 +218 @@
 
     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 char* sourceLimit = source + len;
+    int32_t* offsets = NULL;
     UErrorCode err;
-    
+
     do {
-        UChar *target = buffer;
-        const UChar *targetLimit = target + ConversionBufferSize;
+        UChar* target = buffer;
+        const UChar* targetLimit = target + ConversionBufferSize;
         err = U_ZERO_ERROR;
         ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err);
         int count = target - buffer;
-        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);
 
@@ -216 +243 @@
         return DeprecatedString();
     }
-    
+
     return result;
 }
 
-DeprecatedString StreamingTextDecoder::convert(const unsigned char *chs, int len, bool flush)
-{
+DeprecatedString StreamingTextDecoder::convert(const unsigned char* chs, int len, bool flush)
+{
+    switch (m_encoding.encodingID()) {
+        case UTF16Encoding:
+            return convertUTF16(chs, len);
+
+        case ASCIIEncoding:
+        case Latin1Encoding:
+        case WinLatin1Encoding: {
+            DeprecatedString result;
+            if (convertIfASCII(chs, len, result))
+                return result;
+            break;
+        }
+
+        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;
+            }
+            break;
+
+        default:
+            break;
+    }
+
     //#define PARTIAL_CHARACTER_HANDLING_TEST_CHUNK_SIZE 1000
-
-    switch (m_encoding.encodingID()) {
-    case UTF16Encoding:
-        return convertUTF16(chs, len);
-
-    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;
-            }
-            result += convertUsingICU(chs + i, chunkSize, flush && (i + chunkSize == len));
-        }
-        return result;
+    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;
+        }
+        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 char* chs, int len, bool flush)
 {
     ASSERT_ARG(len, len >= 0);
@@ -266 +311 @@
     int buf1Len = numBufferedBytes;
     int buf2Len = len;
-    const unsigned char *buf1 = m_bufferedBytes;
-    const unsigned char *buf2 = reinterpret_cast<const unsigned char *>(chs);
+    const unsigned char* buf1 = 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;

trunk/WebCore/platform/StreamingTextDecoder.h

@@ -38 +38 @@
         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;

trunk/WebCore/platform/String.cpp

@@ -24 +24 @@
 #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)
@@ -51 +53 @@
         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());
 }
 
@@ -77 +79 @@
 }
 
-String& String::operator+=(const String &str)
+void String::append(const String &str)
 {
     if (str.m_impl) {
@@ -83 +85 @@
             // ### FIXME!!!
             m_impl = str.m_impl;
-            return *this;
+            return;
         }
         m_impl = m_impl->copy();
         m_impl->append(str.m_impl.get());
     }
-    return *this;
 }
 
@@ -112 +113 @@
 }
 
-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)
 {
@@ -140 +121 @@
 }
 
-const QChar& String::operator[](unsigned i) const
-{
-    static const QChar nullChar = 0;
-    if (!m_impl || i >= m_impl->length() )
-        return nullChar;
-    return *(m_impl->unicode()+i);
+UChar String::operator[](unsigned i) const
+{
+    if (!m_impl || i >= m_impl->length())
+        return 0;
+    return m_impl->characters()[i];
 }
 
@@ -195 +175 @@
 }
 
+String String::foldCase() const
+{
+    if (!m_impl)
+        return String();
+    return m_impl->foldCase();
+}
+
 bool String::percentage(int& result) const
 {
@@ -200 +187 @@
         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();
 }
 
@@ -218 +205 @@
     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());
 }
 
@@ -230 +217 @@
     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;
@@ -237 +224 @@
             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.
@@ -309 +296 @@
 bool String::isEmpty() const
 {
-    return (!m_impl || m_impl->length() == 0);
+    return !m_impl || !m_impl->length();
 }
 
@@ -334 +321 @@
     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;
@@ -347 +334 @@
         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());
 }
 
@@ -358 +345 @@
         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());
 }
 
@@ -365 +352 @@
     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());
 }
 
@@ -372 +359 @@
     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());
+}
+
+}

trunk/WebCore/platform/StringHash.h

@@ -25 +25 @@
 #include "PlatformString.h"
 #include <wtf/HashTraits.h>
+#include <unicode/uchar.h>
+#include <unicode/ustring.h>
 
 namespace WTF {
@@ -44 +46 @@
                 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;
@@ -69 +71 @@
         {
             unsigned l = str->length();
-            const QChar* s = str->unicode();
+            const UChar* s = str->characters();
             uint32_t hash = PHI;
             uint32_t tmp;
@@ -78 +80 @@
             // 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;
@@ -87 +89 @@
             // 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;
@@ -124 +126 @@
             // 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;
@@ -133 +135 @@
             // 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;
@@ -156 +158 @@
         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;
-        }
-    };
-
-    template<> struct StrHash<WebCore::AtomicStringImpl*> : public StrHash<WebCore::StringImpl*> {
-    };
+            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<RefPtr<WebCore::StringImpl> > {

trunk/WebCore/platform/StringImpl.cpp

@@ -29 +29 @@
 
 #include "AtomicString.h"
+#include "DeprecatedString.h"
 #include "Length.h"
 #include "StringHash.h"
@@ -34 +35 @@
 #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)
-{
-    return static_cast<QChar*>(fastMalloc(sizeof(QChar) * n));
-}
-
-static inline void deleteQCharVector(QChar* p)
+const UChar nonBreakingSpace = 0xA0;
+
+static inline UChar* newUCharVector(unsigned n)
+{
+    return static_cast<UChar*>(fastMalloc(sizeof(UChar) * n));
+}
+
+static inline void deleteUCharVector(UChar* p)
 {
     fastFree(p);
@@ -60 +66 @@
 StringImpl::StringImpl(const DeprecatedString& str)
 {
-    initWithQChar(str.unicode(), str.length());
-}
-
-StringImpl::StringImpl(const QChar* str, unsigned len)
-{
-    initWithQChar(str, len);
+    init(reinterpret_cast<const UChar*>(str.unicode()), str.length());
+}
+
+StringImpl::StringImpl(const UChar* str, unsigned 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);
-}
-
-void StringImpl::initWithChar(const char* str, unsigned len)
+    init(str, len);
+}
+
+void StringImpl::init(const char* str, unsigned len)
 {
     m_hash = 0;
@@ -88 +94 @@
     }
     
-    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;
@@ -105 +111 @@
     }
     
-    m_data = newQCharVector(len);
-    memcpy(m_data, str, len * sizeof(QChar));
+    m_data = newUCharVector(len);
+    memcpy(m_data, str, len * sizeof(UChar));
 }
 
@@ -113 +119 @@
     if (m_inTable)
         AtomicString::remove(this);
-    deleteQCharVector(m_data);
+    deleteUCharVector(m_data);
 }
 
@@ -122 +128 @@
     {
         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;
@@ -140 +146 @@
     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;
@@ -156 +162 @@
         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;
@@ -168 +174 @@
     if (len <= 0)
         return;
-    if (pos >= m_length )
+    if (pos >= m_length)
         return;
     if ((unsigned)len > m_length - pos)
@@ -174 +180 @@
 
     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;
@@ -188 +194 @@
 
     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);
@@ -205 +211 @@
     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;
 }
@@ -227 +229 @@
 }
 
-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)
@@ -233 +235 @@
 
     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);
         }
@@ -266 +264 @@
     } 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);
         }
@@ -285 +281 @@
 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();
@@ -307 +302 @@
 
     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;
@@ -321 +316 @@
         return 0;
     }
-    DeprecatedString str(m_data, m_length);
+    DeprecatedString str(reinterpret_cast<const QChar*>(m_data), m_length);
     str = str.simplifyWhiteSpace();
 
@@ -331 +326 @@
     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;
     }
@@ -338 +333 @@
     /* 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--;
@@ -347 +342 @@
 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;
 }
 
@@ -360 +366 @@
         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].lower();
-
+    UChar* data = newUCharVector(m_length);
+    int length = m_length;
+
+    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;
 }
@@ -374 +411 @@
     if (!m_length)
         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();
-
+    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;
 }
 
-static UBreakIterator* getWordBreakIterator(const QChar* string, int length)
+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 UChar* string, int length)
 {
     // The locale is currently ignored when determining character cluster breaks.
@@ -401 +461 @@
     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;
 
@@ -407 +467 @@
 }
 
-StringImpl* StringImpl::capitalize(QChar previous) const
+StringImpl* StringImpl::capitalize(UChar previous) const
 {
     StringImpl* capitalizedString = new StringImpl;
@@ -413 +473 @@
         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.
@@ -423 +482 @@
             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;
     
@@ -437 +496 @@
     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;
 }
@@ -451 +510 @@
 
     // 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.
@@ -461 +519 @@
     
     // 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);
-}
-
-static bool equal(const QChar* a, const char* b, int m_length)
-{
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (*a != *b)
+    
+    return QConstString(reinterpret_cast<const QChar*>(m_data), i).string().toInt(ok);
+}
+
+static bool equal(const UChar* a, const char* b, int length)
+{
+    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)
-{
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (tolower(a->unicode()) != tolower(*b))
+static bool equalIgnoringCase(const UChar* a, const char* b, int length)
+{
+    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)
-{
-    ASSERT(m_length >= 0);
-    while (m_length--) {
-        if (tolower(a->unicode()) != tolower(b->unicode()))
-            return false;
-        a++; b++;
-    }
-    return true;
+static inline bool equalIgnoringCase(const UChar* a, const UChar* b, int length)
+{
+    ASSERT(length >= 0);
+    return u_memcasecmp(a, b, length, U_FOLD_CASE_DEFAULT) == 0;
 }
 
@@ -524 +576 @@
     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))
@@ -532 +584 @@
         } 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);
@@ -542 +595 @@
 }
 
-int StringImpl::find(const QChar c, int start) const
+int StringImpl::find(const UChar c, int start) const
 {
     unsigned int index = start;
@@ -566 +619 @@
       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);
@@ -580 +632 @@
         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++;
         }
@@ -626 +678 @@
 }
 
-StringImpl* StringImpl::replace(QChar oldC, QChar newC)
+StringImpl* StringImpl::replace(UChar oldC, UChar newC)
 {
     if (oldC == newC)
@@ -639 +691 @@
     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;
@@ -660 +712 @@
 }
 
-StringImpl* StringImpl::replace(QChar pattern, const StringImpl* str)
+StringImpl* StringImpl::replace(UChar pattern, const StringImpl* str)
 {
     int slen = str ? str->length() : 0;
@@ -685 +737 @@
 
     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;
     }
@@ -697 +749 @@
 }
 
-bool equal(const char* a, const StringImpl* b)
+bool equalIgnoringCase(const StringImpl* a, const StringImpl* b)
+{
+    return CaseInsensitiveHash::equal(a, b);
+}
+
+bool equalIgnoringCase(const StringImpl* a, const char* b)
 {
     if (!a)
@@ -704 +761 @@
         return !a;
 
-    unsigned length = b->length();
-    const QChar* bs = b->unicode();
+    unsigned length = a->length();
+    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 = a[i];
-        if (!c)
+        unsigned char bc = b[i];
+        if (!bc)
             return false;
-        if (c != bs[i])
-            return false;
-    }
-
-    return !a[length];
-}
-
-bool equalIgnoringCase(const StringImpl* a, const StringImpl* b)
-{
-    return CaseInsensitiveHash::equal(a, b);
-}
-
-bool equalIgnoringCase(const StringImpl* a, const char* b)
-{
-    if (!a)
-        return !b;
-    if (!b)
-        return !a;
-
-    unsigned length = a->length();
-    const QChar* as = a->unicode();
-    for (unsigned i = 0; i != length; ++i) {
-        char c = b[i];
-        if (!c)
-            return false;
-        if (as[i].lower() != QChar(c).lower())
-            return false;
-    }
-
-    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;
-    }
-
-    return !a[length];
+        UChar ac = as[i];
+        ored |= ac;
+        equal &= tolower(ac) == tolower(bc);
+    }
+
+    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 equal && !b[length];
 }
 
@@ -768 +793 @@
 // 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;
@@ -779 +804 @@
     // 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;
@@ -788 +813 @@
     // Handle end case
     if (rem) {
-        hash += m_data[0].unicode();
+        hash += m_data[0];
         hash ^= hash << 11;
         hash += hash >> 17;
@@ -861 +886 @@
     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;
@@ -873 +898 @@
 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());
 }
 

trunk/WebCore/platform/StringImpl.h

@@ -25 +25 @@
 #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>
 
@@ -34 +36 @@
 #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*);
     
@@ -71 +73 @@
     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); }
@@ -77 +79 @@
     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;
@@ -92 +94 @@
     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;
 
@@ -102 +105 @@
 
     // 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*);
 
@@ -120 +123 @@
 #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;
     
@@ -134 +139 @@
 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); }
 
 }

trunk/WebCore/platform/TextBoundaries.h

@@ -27 +27 @@
 #define TextBoundaries_h
 
+#include <unicode/umachine.h>
+
 // FIXME: Change clients to use ICU and remove these functions.
-
-class QChar;
 
 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);
 
 }

trunk/WebCore/platform/TextEncoding.cpp

@@ -46 +46 @@
     return charsetNameFromTextEncodingID(m_encodingID);
 }
-
-QChar TextEncoding::backslashAsCurrencySymbol() const
+UChar TextEncoding::backslashAsCurrencySymbol() const
 {
     if (m_flags & BackslashIsYen)
@@ -129 +128 @@
     // 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;

trunk/WebCore/platform/TextEncoding.h

@@ -81 +81 @@
         bool isJapanese() const { return m_flags & IsJapanese; }
         
-        QChar backslashAsCurrencySymbol() const;
+        UChar backslashAsCurrencySymbol() const;
         
         DeprecatedCString fromUnicode(const DeprecatedString&, bool allowEntities = false) const;

trunk/WebCore/platform/mac/FontFamilyMac.mm

@@ -55 +55 @@
             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);

trunk/WebCore/platform/mac/FontMac.mm

@@ -39 +39 @@
 
 #import "IntRect.h"
+
+using namespace std;
 
 namespace WebCore {
@@ -103 +105 @@
 
 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);
@@ -117 +119 @@
 
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)(str+pos), len, from, to);    
+    WebCoreInitializeTextRun(&run, str + pos, len, from, to);
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
@@ -138 +140 @@
 }
                      
-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
 {
@@ -151 +153 @@
         
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)str, len, from, to);    
+    WebCoreInitializeTextRun(&run, str, len, from, to);    
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
@@ -171 +173 @@
 }
 
-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
@@ -185 +187 @@
         
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)str, len, from, to);    
+    WebCoreInitializeTextRun(&run, str, len, from, to);    
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
@@ -223 +225 @@
 }
 
-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);
@@ -229 +231 @@
 
     WebCoreTextRun run;
-    WebCoreInitializeTextRun(&run, (const UniChar *)uchars, slen, pos, pos+len);
+    WebCoreInitializeTextRun(&run, uchars, slen, pos, pos + len);
     
     WebCoreTextStyle style;
@@ -244 +246 @@
 }
 
-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);
@@ -250 +252 @@
     
     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;

trunk/WebCore/platform/mac/TextBoundaries.mm

@@ -32 +32 @@
 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];
@@ -44 +44 @@
 }
 
-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];
@@ -100 +100 @@
 }
 
-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;
@@ -106 +106 @@
 
     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);
@@ -124 +123 @@
 }
 
-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) {

trunk/WebCore/platform/mac/TextEncodingMac.cpp

@@ -52 +52 @@
     // 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

trunk/WebCore/rendering/InlineTextBox.cpp

@@ -119 +119 @@
 
     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)
@@ -334 +334 @@
             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 {
@@ -343 +343 @@
             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);
             }
@@ -367 +367 @@
                                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)
@@ -452 +452 @@
     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();
@@ -476 +476 @@
     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();
@@ -575 +575 @@
     
     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();
@@ -689 +689 @@
     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);
@@ -704 +704 @@
     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();
 }

trunk/WebCore/rendering/RenderBlock.cpp

@@ -2832 +2832 @@
         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)
@@ -3398 +3398 @@
             
             // 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++;
             

trunk/WebCore/rendering/RenderFlexibleBox.cpp

@@ -729 +729 @@
                 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);
@@ -742 +744 @@
                 
                 // 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;
-
-                const unsigned short ellipsisAndSpace[2] = { 0x2026, ' ' };
+                if (!lastVisibleLine)
+                    continue;
+
+                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
@@ -770 +779 @@
                 
                 // 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());

trunk/WebCore/rendering/RenderImage.cpp

@@ -105 +105 @@
         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));
         }
@@ -238 +238 @@
             if (!m_altText.isEmpty()) {
                 DeprecatedString text = m_altText.deprecatedString();
-                text.replace(QChar('\\'), backslashAsCurrencySymbol());
+                text.replace('\\', backslashAsCurrencySymbol());
                 p->setFont(style()->font());
                 p->setPen(style()->color());
@@ -248 +248 @@
                 // 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);
             }
         }

trunk/WebCore/rendering/RenderObject.cpp

@@ -2497 +2497 @@
 }
 
-QChar RenderObject::backslashAsCurrencySymbol() const
+UChar RenderObject::backslashAsCurrencySymbol() const
 {
     if (Node *node = element())

trunk/WebCore/rendering/RenderObject.h

@@ -845 +845 @@
 
     // Convenience, to avoid repeating the code to dig down to get this.
-    QChar backslashAsCurrencySymbol() const;
+    UChar backslashAsCurrencySymbol() const;
 
     virtual int caretMinOffset() const;

trunk/WebCore/rendering/RenderText.cpp

@@ -59 +59 @@
 
     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;
@@ -102 +102 @@
     if (str)
         str = str->replace('\\', backslashAsCurrencySymbol());
-    KHTMLAssert(!str || !str->length() || str->unicode());
+    KHTMLAssert(!str || !str->length() || str->characters());
 }
 
@@ -437 +437 @@
     unsigned i;
     for (i = 0; i < str->length(); i++)
-        if ((*str)[i].unicode() >= 0x7f) {
+        if ((*str)[i] > 0x7f) {
             m_allAscii = false;
             return m_allAscii;
@@ -457 +457 @@
 void RenderText::cacheWidths()
 {
-    const Font *f = font(false);
+    const Font* f = font(false);
     if (shouldUseMonospaceCache(f)) {
-        QChar c(' ');
+        const UChar c = ' ';
         m_monospaceCharacterWidth = (int)f->floatWidth(&c, 1, 0, 1, 0, 0);
     } else {
@@ -466 +466 @@
 }
 
-ALWAYS_INLINE int RenderText::widthFromCache(const Font *f, int start, int len, int tabWidth, int xpos) const
+ALWAYS_INLINE int RenderText::widthFromCache(const Font* f, int start, int len, int tabWidth, int xpos) const
 {
     if (m_monospaceCharacterWidth != 0) {
         int i, w = 0;
         for (i = start; i < start+len; i++) {
-            QChar c = (*str)[i];
-            int dir = c.direction();
-            if (dir != QChar::DirNSM && dir != QChar::DirBN) {
-                if (c == '\t' && tabWidth != 0) {
+            UChar c = (*str)[i];
+            UCharDirection dir = u_charDirection(c);
+            if (dir != U_DIR_NON_SPACING_MARK && dir != U_BOUNDARY_NEUTRAL) {
+                if (c == '\t' && tabWidth != 0)
                     w += tabWidth - ((xpos + w) % tabWidth);
-                } else
+                else
                     w += m_monospaceCharacterWidth;
-                if (c.isSpace() && i>start && !(*str)[i-1].isSpace())
+                if (QChar(c).isSpace() && i > start && !QChar((*str)[i - 1]).isSpace())
                     w += f->wordSpacing();        
             }
@@ -486 +486 @@
     }
     
-    return f->width(str->unicode(), str->length(), start, len, tabWidth, xpos);
+    return f->width(str->characters(), str->length(), start, len, tabWidth, xpos);
 }
 
@@ -524 +524 @@
     if (stripFrontSpaces && ((*str)[0] == ' ' || ((*str)[0] == '\n' && !style()->preserveNewline()) || (*str)[0] == '\t')) {
         const Font *f = font(false); // FIXME: Why is it ok to ignore first-line here?
-        QChar space[1]; space[0] = ' ';
-        int spaceWidth = f->width(space, 1);
+        const UChar space = ' ';
+        int spaceWidth = f->width(&space, 1);
         maxW -= spaceWidth + f->wordSpacing();
     }
@@ -591 +591 @@
     
     // FIXME: not 100% correct for first-line
-    const Font *f = font(false);
+    const Font* f = font(false);
     int wordSpacing = style()->wordSpacing();
     int len = str->length();
-    const QChar *txt = str->unicode();
+    const UChar* txt = str->characters();
     bool needsWordSpacing = false;
     bool ignoringSpaces = false;
@@ -601 +601 @@
     bool firstLine = true;
     int nextBreakable = -1;
-    for(int i = 0; i < len; i++)
-    {
-        QChar c = txt[i];
+    for (int i = 0; i < len; i++) {
+        UChar c = txt[i];
         
         bool previousCharacterIsSpace = isSpace;
@@ -637 +636 @@
         
         // Ignore spaces and soft hyphens
-        if (ignoringSpaces || c.unicode() == SOFT_HYPHEN) {
+        if (ignoringSpaces || c == SOFT_HYPHEN) {
             continue;
         }
@@ -643 +642 @@
         bool hasBreak = isBreakable(txt, i, len, nextBreakable);
         int j = i;
-        while (c != '\n' && c != ' ' && c != '\t' && c.unicode() != SOFT_HYPHEN) {
+        while (c != '\n' && c != ' ' && c != '\t' && c != SOFT_HYPHEN) {
             j++;
             if (j == len)
@@ -736 +735 @@
     unsigned currPos;
     for (currPos = from; 
-         currPos < from+len && ((*str)[currPos] == '\n' || (*str)[currPos].unicode() == ' ' || (*str)[currPos] == '\t'); 
+         currPos < from+len && ((*str)[currPos] == '\n' || (*str)[currPos] == ' ' || (*str)[currPos] == '\t'); 
          currPos++);
     return currPos >= (from+len);
@@ -883 +882 @@
                     // find previous text renderer if one exists
                     RenderObject* o;
-                    QChar previous = ' ';
+                    UChar previous = ' ';
                     for (o = previousInPreOrder(); o && o->isInlineFlow(); o = o->previousInPreOrder())
                         ;
@@ -906 +905 @@
     // RenderBR object ?
     KHTMLAssert(!isBR() || (str->length() == 1 && (*str)[0] == '\n'));
-    KHTMLAssert(!str->length() || str->unicode());
+    KHTMLAssert(!str->length() || str->characters());
 
     setNeedsLayoutAndMinMaxRecalc();
@@ -985 +984 @@
 unsigned int RenderText::width(unsigned int from, unsigned int len, const Font *f, int xpos) const
 {
-    if (!str->unicode() || from > str->length())
+    if (!str->characters() || from > str->length())
         return 0;
     if (from + len > str->length())
@@ -996 +995 @@
         w = widthFromCache(f, from, len, tabWidth(), xpos);
     else
-        w = f->width(str->unicode(), str->length(), from, len, tabWidth(), xpos );
+        w = f->width(str->characters(), str->length(), from, len, tabWidth(), xpos );
         
     return w;

trunk/WebCore/rendering/RenderText.h

@@ -79 +79 @@
     virtual VisiblePosition positionForCoordinates(int x, int y);
 
-    unsigned int length() const { return str->length(); }
-    const QChar* text() const { return str->unicode(); }
-    unsigned int stringLength() const { return str->length(); } // non virtual implementation of length()
+    virtual unsigned length() const { return str->length(); }
+    const UChar* text() const { return str->characters(); }
+    unsigned stringLength() const { return str->length(); } // non virtual implementation of length()
     virtual void position(InlineBox* box, int from, int len, bool reverse, bool override);
 
-    virtual unsigned int width(unsigned int from, unsigned int len, const Font *f, int xpos) const;
-    virtual unsigned int width(unsigned int from, unsigned int len, int xpos, bool firstLine = false) const;
+    virtual unsigned width(unsigned from, unsigned len, const Font*, int xpos) const;
+    virtual unsigned width(unsigned from, unsigned len, int xpos, bool firstLine = false) const;
     virtual int width() const;
     virtual int height() const;
@@ -105 +105 @@
                                     int& minW, int& maxW, bool& stripFrontSpaces);
     
-    bool containsOnlyWhitespace(unsigned int from, unsigned int len) const;
+    bool containsOnlyWhitespace(unsigned from, unsigned len) const;
     
     // returns the minimum x position of all runs relative to the parent.

trunk/WebCore/rendering/RenderTextField.cpp

@@ -121 +121 @@
             if (value.isNull())
                 value = "";
-            value.replace(QChar('\\'), backslashAsCurrencySymbol());
+            value.replace('\\', backslashAsCurrencySymbol());
             if (value != oldText) {
                 ExceptionCode ec = 0;
@@ -231 +231 @@
             size = 20;
 
-        QChar ch[1];
-        ch[0] = '0';
-        int sizeWidth = (int)ceilf(style()->font().floatWidth(ch, 1, 0, 1, 0, 0, false) * size);
+        const UChar ch = '0';
+        int sizeWidth = (int)ceilf(style()->font().floatWidth(&ch, 1, 0, 1, 0, 0, false) * size);
         m_maxWidth = sizeWidth;
     }

trunk/WebCore/rendering/RenderTreeAsText.cpp

@@ -207 +207 @@
     result += '"';
     for (unsigned i = 0; i != s.length(); ++i) {
-        QChar c = s[i];
+        UChar c = s[i];
         if (c == '\\')
             result += "\\\\";
         else if (c == '"')
             result += "\\\"";
-        else if (c == '\n' || c.unicode() == 0x00A0)
+        else if (c == '\n' || c == 0x00A0)
             result += ' ';
         else {
-            unsigned short u = c.unicode();
-            if (u >= 0x20 && u < 0x7F)
+            if (c >= 0x20 && c < 0x7F)
                 result += c;
             else {
                 DeprecatedString hex;
+                unsigned u = c;
                 hex.sprintf("\\x{%X}", u);
                 result += hex;

trunk/WebCore/rendering/bidi.cpp

@@ -3 +3 @@
  *
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2004 Apple Computer, Inc.
+ * Copyright (C) 2004, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
@@ -39 +39 @@
 
 // an iterator which traverses all the objects within a block
-struct BidiIterator
-{
+struct BidiIterator {
     BidiIterator() : block(0), obj(0), pos(0) {}
     BidiIterator(RenderBlock* b, RenderObject* o, unsigned int p) 
-     :block(b), obj(o), pos(p) {}
+        : block(b), obj(o), pos(p) {}
     
     void increment(BidiState& state);
     bool atEnd() const;
     
-    const QChar& current() const;
-    
-    QChar::Direction direction() const;
+    UChar current() const;
+    UCharDirection direction() const;
 
     RenderBlock* block;
@@ -58 +56 @@
 
 struct BidiState {
-    BidiState() : context(0), dir(QChar::DirON), adjustEmbedding(false), reachedEndOfLine(false) {}
+    BidiState() : context(0), dir(U_OTHER_NEUTRAL), adjustEmbedding(false), reachedEndOfLine(false) {}
     
     BidiIterator sor;
@@ -66 +64 @@
     RefPtr<BidiContext> context;
     BidiStatus status;
-    QChar::Direction dir;
+    UCharDirection dir;
     bool adjustEmbedding;
     BidiIterator endOfLine;
@@ -105 +103 @@
 static int numSpaces;
 
-static void embed(QChar::Direction d, BidiState &bidi);
-static void appendRun(BidiState &bidi);
+static void embed(UCharDirection, BidiState&);
+static void appendRun(BidiState&);
 
 static int getBPMWidth(int childValue, Length cssUnit)
@@ -200 +198 @@
    relayouting
 */
-BidiContext::BidiContext(unsigned char l, QChar::Direction e, BidiContext *p, bool o)
+BidiContext::BidiContext(unsigned char l, UCharDirection e, BidiContext *p, bool o)
     : level(l), override(o), m_dir(e)
 {
@@ -281 +279 @@
                 if (ub != UBNormal) {
                     TextDirection dir = next->style()->direction();
-                    QChar::Direction d = (ub == Embed
-                        ? (dir == RTL ? QChar::DirRLE : QChar::DirLRE)
-                        : (dir == RTL ? QChar::DirRLO : QChar::DirLRO));
+                    UCharDirection d = (ub == Embed
+                        ? (dir == RTL ? U_RIGHT_TO_LEFT_EMBEDDING : U_LEFT_TO_RIGHT_EMBEDDING)
+                        : (dir == RTL ? U_RIGHT_TO_LEFT_OVERRIDE : U_LEFT_TO_RIGHT_OVERRIDE));
                     embed(d, bidi);
                 }
@@ -299 +297 @@
             while (current && current != block) {
                 if (bidi.adjustEmbedding && current->isInlineFlow() && current->style()->unicodeBidi() != UBNormal)
-                    embed(QChar::DirPDF, bidi);
+                    embed(U_POP_DIRECTIONAL_FORMAT, bidi);
 
                 next = current->nextSibling();
@@ -307 +305 @@
                         if (ub != UBNormal) {
                             TextDirection dir = next->style()->direction();
-                            QChar::Direction d = (ub == Embed
-                                ? (dir == RTL ? QChar::DirRLE : QChar::DirLRE)
-                                : (dir == RTL ? QChar::DirRLO : QChar::DirLRO));
+                            UCharDirection d = (ub == Embed
+                                ? (dir == RTL ? U_RIGHT_TO_LEFT_EMBEDDING : U_LEFT_TO_RIGHT_EMBEDDING)
+                                : (dir == RTL ? U_RIGHT_TO_LEFT_OVERRIDE : U_LEFT_TO_RIGHT_OVERRIDE));
                             embed(d, bidi);
                         }
@@ -349 +347 @@
             if (ub != UBNormal) {
                 TextDirection dir = o->style()->direction();
-                QChar::Direction d = (ub == Embed
-                    ? (dir == RTL ? QChar::DirRLE : QChar::DirLRE)
-                    : (dir == RTL ? QChar::DirRLO : QChar::DirLRO));
+                UCharDirection d = (ub == Embed
+                    ? (dir == RTL ? U_RIGHT_TO_LEFT_EMBEDDING : U_LEFT_TO_RIGHT_EMBEDDING)
+                    : (dir == RTL ? U_RIGHT_TO_LEFT_OVERRIDE : U_LEFT_TO_RIGHT_OVERRIDE));
                 embed(d, bidi);
             }
@@ -387 +385 @@
 }
 
-const QChar& BidiIterator::current() const
-{
-    static QChar nullCharacter;
-    
+UChar BidiIterator::current() const
+{
     if (!obj || !obj->isText())
-        return nullCharacter;
+        return 0;
     
     RenderText* text = static_cast<RenderText*>(obj);
     if (!text->text())
-        return nullCharacter;
+        return 0;
     
     return text->text()[pos];
 }
 
-ALWAYS_INLINE QChar::Direction BidiIterator::direction() const
+ALWAYS_INLINE UCharDirection BidiIterator::direction() const
 {
     if (!obj)
-        return QChar::DirON;
+        return U_OTHER_NEUTRAL;
     if (obj->isListMarker())
-        return obj->style()->direction() == LTR ? QChar::DirL : QChar::DirR;
+        return obj->style()->direction() == LTR ? U_LEFT_TO_RIGHT : U_RIGHT_TO_LEFT;
     if (!obj->isText())
-        return QChar::DirON;
-
-    RenderText *renderTxt = static_cast<RenderText *>(obj);
+        return U_OTHER_NEUTRAL;
+    RenderText* renderTxt = static_cast<RenderText*>(obj);
     if (pos >= renderTxt->stringLength())
-        return QChar::DirON;
-    return renderTxt->text()[pos].direction();
+        return U_OTHER_NEUTRAL;
+    return u_charDirection(renderTxt->text()[pos]);
 }
 
@@ -434 +429 @@
         if (text->text()) {
             for (int i = bidiRun->start; i < bidiRun->stop; i++) {
-                const QChar c = text->text()[i];
+                UChar c = text->text()[i];
                 if (c == ' ' || c == '\n' || c == '\t')
                     numSpaces++;
@@ -525 +520 @@
                     RenderText* textObj = static_cast<RenderText*>(endpoint.obj);
                     if (endpoint.pos+1 < textObj->length()) {
-                        if (textObj->text()[endpoint.pos+1].unicode() == SOFT_HYPHEN)
+                        if (textObj->text()[endpoint.pos+1] == SOFT_HYPHEN)
                             return;
                     } else if (startpoint.obj->isText()) {
                         RenderText *startText = static_cast<RenderText*>(startpoint.obj);
-                        if (startText->length() > 0 && startText->text()[0].unicode() == SOFT_HYPHEN)
+                        if (startText->length() > 0 && startText->text()[0] == SOFT_HYPHEN)
                             return;
                     }
@@ -626 +621 @@
     bidi.eor.increment(bidi);
     bidi.sor = bidi.eor;
-    bidi.dir = QChar::DirON;
-    bidi.status.eor = QChar::DirON;
+    bidi.dir = U_OTHER_NEUTRAL;
+    bidi.status.eor = U_OTHER_NEUTRAL;
     bidi.adjustEmbedding = b;
 }
 
-static void embed(QChar::Direction d, BidiState& bidi)
+static void embed(UCharDirection d, BidiState& bidi)
 {
     bool b = bidi.adjustEmbedding;
     bidi.adjustEmbedding = false;
-    if (d == QChar::DirPDF) {
+    if (d == U_POP_DIRECTIONAL_FORMAT) {
         BidiContext *c = bidi.context->parent;
         if (c) {
             if (!emptyRun && bidi.eor != bidi.last) {
-                assert(bidi.status.eor != QChar::DirON);
+                assert(bidi.status.eor != U_OTHER_NEUTRAL);
                 // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
-                assert(bidi.status.last == QChar::DirES || bidi.status.last == QChar::DirET || bidi.status.last == QChar::DirCS || bidi.status.last == QChar::DirBN || bidi.status.last == QChar::DirB || bidi.status.last == QChar::DirS || bidi.status.last == QChar::DirWS || bidi.status.last == QChar::DirON);
-                if (bidi.dir == QChar::DirON)
+                assert(bidi.status.last == U_EUROPEAN_NUMBER_SEPARATOR
+                    || bidi.status.last == U_EUROPEAN_NUMBER_TERMINATOR
+                    || bidi.status.last == U_COMMON_NUMBER_SEPARATOR
+                    || bidi.status.last == U_BOUNDARY_NEUTRAL
+                    || bidi.status.last == U_BLOCK_SEPARATOR
+                    || bidi.status.last == U_SEGMENT_SEPARATOR
+                    || bidi.status.last == U_WHITE_SPACE_NEUTRAL
+                    || bidi.status.last == U_OTHER_NEUTRAL);
+                if (bidi.dir == U_OTHER_NEUTRAL)
                     bidi.dir = bidi.context->dir();
-                if (bidi.context->dir() == QChar::DirL) {
+                if (bidi.context->dir() == U_LEFT_TO_RIGHT) {
                     // bidi.sor ... bidi.eor ... bidi.last L
-                    if (bidi.status.eor == QChar::DirEN) {
-                        if (bidi.status.lastStrong != QChar::DirL) {
-                            bidi.dir = QChar::DirEN;
+                    if (bidi.status.eor == U_EUROPEAN_NUMBER) {
+                        if (bidi.status.lastStrong != U_LEFT_TO_RIGHT) {
+                            bidi.dir = U_EUROPEAN_NUMBER;
                             appendRun(bidi);
                         }
-                    } else if (bidi.status.eor == QChar::DirAN) {
-                        bidi.dir = QChar::DirAN;
+                    } else if (bidi.status.eor == U_ARABIC_NUMBER) {
+                        bidi.dir = U_ARABIC_NUMBER;
                         appendRun(bidi);
-                    } else if (bidi.status.eor != QChar::DirL)
+                    } else if (bidi.status.eor != U_LEFT_TO_RIGHT)
                         appendRun(bidi);
-                } else if (bidi.status.eor != QChar::DirR && bidi.status.eor != QChar::DirAL)
+                } else if (bidi.status.eor != U_RIGHT_TO_LEFT && bidi.status.eor != U_RIGHT_TO_LEFT_ARABIC)
                     appendRun(bidi);
                 bidi.eor = bidi.last;
@@ -670 +672 @@
         }
     } else {
-        QChar::Direction runDir;
-        if (d == QChar::DirRLE || d == QChar::DirRLO)
-            runDir = QChar::DirR;
+        UCharDirection runDir;
+        if (d == U_RIGHT_TO_LEFT_EMBEDDING || d == U_RIGHT_TO_LEFT_OVERRIDE)
+            runDir = U_RIGHT_TO_LEFT;
         else
-            runDir = QChar::DirL;
-        bool override = d == QChar::DirLRO || d == QChar::DirRLO;
+            runDir = U_LEFT_TO_RIGHT;
+        bool override = d == U_LEFT_TO_RIGHT_OVERRIDE || d == U_RIGHT_TO_LEFT_OVERRIDE;
 
         unsigned char level = bidi.context->level;
-        if (runDir == QChar::DirR) {
+        if (runDir == U_RIGHT_TO_LEFT) {
             if (level%2) // we have an odd level
                 level += 2;
@@ -692 +694 @@
         if (level < 61) {
             if (!emptyRun && bidi.eor != bidi.last) {
-                assert(bidi.status.eor != QChar::DirON);
+                assert(bidi.status.eor != U_OTHER_NEUTRAL);
                 // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
-                assert(bidi.status.last == QChar::DirES || bidi.status.last == QChar::DirET || bidi.status.last == QChar::DirCS || bidi.status.last == QChar::DirBN || bidi.status.last == QChar::DirB || bidi.status.last == QChar::DirS || bidi.status.last == QChar::DirWS || bidi.status.last == QChar::DirON);
-                if (bidi.dir == QChar::DirON)
+                assert(bidi.status.last == U_EUROPEAN_NUMBER_SEPARATOR
+                    || bidi.status.last == U_EUROPEAN_NUMBER_TERMINATOR
+                    || bidi.status.last == U_COMMON_NUMBER_SEPARATOR
+                    || bidi.status.last == U_BOUNDARY_NEUTRAL
+                    || bidi.status.last == U_BLOCK_SEPARATOR
+                    || bidi.status.last == U_SEGMENT_SEPARATOR
+                    || bidi.status.last == U_WHITE_SPACE_NEUTRAL
+                    || bidi.status.last == U_OTHER_NEUTRAL);
+                if (bidi.dir == U_OTHER_NEUTRAL)
                     bidi.dir = runDir;
-                if (runDir == QChar::DirL) {
+                if (runDir == U_LEFT_TO_RIGHT) {
                     // bidi.sor ... bidi.eor ... bidi.last L
-                    if (bidi.status.eor == QChar::DirEN) {
-                        if (bidi.status.lastStrong != QChar::DirL) {
-                            bidi.dir = QChar::DirEN;
+                    if (bidi.status.eor == U_EUROPEAN_NUMBER) {
+                        if (bidi.status.lastStrong != U_LEFT_TO_RIGHT) {
+                            bidi.dir = U_EUROPEAN_NUMBER;
                             appendRun(bidi);
-                            if (bidi.context->dir() != QChar::DirL)
-                                bidi.dir = QChar::DirR;
+                            if (bidi.context->dir() != U_LEFT_TO_RIGHT)
+                                bidi.dir = U_RIGHT_TO_LEFT;
                         }
-                    } else if (bidi.status.eor == QChar::DirAN) {
-                        bidi.dir = QChar::DirAN;
+                    } else if (bidi.status.eor == U_ARABIC_NUMBER) {
+                        bidi.dir = U_ARABIC_NUMBER;
                         appendRun(bidi);
-                        if (bidi.context->dir() != QChar::DirL) {
+                        if (bidi.context->dir() != U_LEFT_TO_RIGHT) {
                             bidi.eor = bidi.last;
-                            bidi.dir = QChar::DirR;
+                            bidi.dir = U_RIGHT_TO_LEFT;
                             appendRun(bidi);
                         }
-                    } else if (bidi.status.eor != QChar::DirL) {
-                        if (bidi.context->dir() == QChar::DirL || bidi.status.lastStrong == QChar::DirL)
+                    } else if (bidi.status.eor != U_LEFT_TO_RIGHT) {
+                        if (bidi.context->dir() == U_LEFT_TO_RIGHT || bidi.status.lastStrong == U_LEFT_TO_RIGHT)
                             appendRun(bidi);
                         else
-                            bidi.dir = QChar::DirR; 
+                            bidi.dir = U_RIGHT_TO_LEFT; 
                     }
-                } else if (bidi.status.eor != QChar::DirR && bidi.status.eor != QChar::DirAL) {
+                } else if (bidi.status.eor != U_RIGHT_TO_LEFT && bidi.status.eor != U_RIGHT_TO_LEFT_ARABIC) {
                     // bidi.sor ... bidi.eor ... bidi.last R; bidi.eor=L/EN/AN; EN,AN behave like R (rule N1)
-                    if (bidi.context->dir() == QChar::DirR || bidi.status.lastStrong == QChar::DirR || bidi.status.lastStrong == QChar::DirAL)
+                    if (bidi.context->dir() == U_RIGHT_TO_LEFT || bidi.status.lastStrong == U_RIGHT_TO_LEFT || bidi.status.lastStrong == U_RIGHT_TO_LEFT_ARABIC)
                         appendRun(bidi);
                     else
-                        bidi.dir = QChar::DirL; 
+                        bidi.dir = U_LEFT_TO_RIGHT;
                 }
                 bidi.eor = bidi.last;
@@ -836 +845 @@
 
     if (!m_tabWidth) {
-        QChar spaceChar(' ');
+        const UChar spaceChar = ' ';
         const Font& font = style()->font();
         int spaceWidth = font.width(&spaceChar, 1);
@@ -864 +873 @@
             int rtLength = rt->length();
             if (rtLength != 0) {
-                if (r->start == 0 && needsWordSpacing && rt->text()[r->start].isSpace())
+                if (r->start == 0 && needsWordSpacing && QChar(rt->text()[r->start]).isSpace())
                     effectiveWidth += rt->font(m_firstLine)->wordSpacing();
-                needsWordSpacing = !rt->text()[r->stop-1].isSpace() && r->stop == rtLength;          
+                needsWordSpacing = !QChar(rt->text()[r->stop-1]).isSpace() && r->stop == rtLength;          
             }
             if (!r->compact) {
@@ -909 +918 @@
             numSpaces = 0;
             // for right to left fall through to right aligned
-            if (bidi.context->basicDir() == QChar::DirL)
+            if (bidi.context->basicDir() == U_LEFT_TO_RIGHT)
                 break;
         case RIGHT:
@@ -937 +946 @@
                 int spaces = 0;
                 for ( int i = r->start; i < r->stop; i++ ) {
-                    const QChar c = static_cast<RenderText *>(r->obj)->text()[i];
+                    UChar c = static_cast<RenderText*>(r->obj)->text()[i];
                     if (c == ' ' || c == '\n' || c == '\t')
                         spaces++;
@@ -1003 +1012 @@
     sBidiRunCount = 0;
 
-    assert(bidi.dir == QChar::DirON);
+    assert(bidi.dir == U_OTHER_NEUTRAL);
 
     emptyRun = true;
@@ -1017 +1026 @@
 
     while (true) {
-        QChar::Direction dirCurrent;
+        UCharDirection dirCurrent;
         if (pastEnd && (previousLineBrokeCleanly || bidi.current.atEnd())) {
             BidiContext *c = bidi.context.get();
@@ -1033 +1042 @@
         } else {
             dirCurrent = bidi.current.direction();
-            if (bidi.context->override && dirCurrent != QChar::DirRLE && dirCurrent != QChar::DirLRE && dirCurrent != QChar::DirRLO && dirCurrent != QChar::DirLRO && dirCurrent != QChar::DirPDF)
+            if (bidi.context->override
+                    && dirCurrent != U_RIGHT_TO_LEFT_EMBEDDING
+                    && dirCurrent != U_LEFT_TO_RIGHT_EMBEDDING
+                    && dirCurrent != U_RIGHT_TO_LEFT_OVERRIDE
+                    && dirCurrent != U_LEFT_TO_RIGHT_OVERRIDE
+                    && dirCurrent != U_POP_DIRECTIONAL_FORMAT)
                 dirCurrent = bidi.context->dir();
-            else if (dirCurrent == QChar::DirNSM)
+            else if (dirCurrent == U_DIR_NON_SPACING_MARK)
                 dirCurrent = bidi.status.last;
         }
 
-        assert(bidi.status.eor != QChar::DirON);
+        assert(bidi.status.eor != U_OTHER_NEUTRAL);
         switch (dirCurrent) {
 
         // embedding and overrides (X1-X9 in the Bidi specs)
-        case QChar::DirRLE:
-        case QChar::DirLRE:
-        case QChar::DirRLO:
-        case QChar::DirLRO:
-        case QChar::DirPDF:
+        case U_RIGHT_TO_LEFT_EMBEDDING:
+        case U_LEFT_TO_RIGHT_EMBEDDING:
+        case U_RIGHT_TO_LEFT_OVERRIDE:
+        case U_LEFT_TO_RIGHT_OVERRIDE:
+        case U_POP_DIRECTIONAL_FORMAT:
             embed(dirCurrent, bidi);
             break;
 
             // strong types
-        case QChar::DirL:
+        case U_LEFT_TO_RIGHT:
             switch(bidi.status.last) {
-                case QChar::DirR:
-                case QChar::DirAL:
-                case QChar::DirEN:
-                case QChar::DirAN:
-                    if (bidi.status.last != QChar::DirEN || bidi.status.lastStrong != QChar::DirL)
+                case U_RIGHT_TO_LEFT:
+                case U_RIGHT_TO_LEFT_ARABIC:
+                case U_EUROPEAN_NUMBER:
+                case U_ARABIC_NUMBER:
+                    if (bidi.status.last != U_EUROPEAN_NUMBER || bidi.status.lastStrong != U_LEFT_TO_RIGHT)
                         appendRun(bidi);
                     break;
-                case QChar::DirL:
+                case U_LEFT_TO_RIGHT:
                     break;
-                case QChar::DirES:
-                case QChar::DirET:
-                case QChar::DirCS:
-                case QChar::DirBN:
-                case QChar::DirB:
-                case QChar::DirS:
-                case QChar::DirWS:
-                case QChar::DirON:
-                    if (bidi.status.eor == QChar::DirEN) {
-                        if (bidi.status.lastStrong != QChar::DirL) {
+                case U_EUROPEAN_NUMBER_SEPARATOR:
+                case U_EUROPEAN_NUMBER_TERMINATOR:
+                case U_COMMON_NUMBER_SEPARATOR:
+                case U_BOUNDARY_NEUTRAL:
+                case U_BLOCK_SEPARATOR:
+                case U_SEGMENT_SEPARATOR:
+                case U_WHITE_SPACE_NEUTRAL:
+                case U_OTHER_NEUTRAL:
+                    if (bidi.status.eor == U_EUROPEAN_NUMBER) {
+                        if (bidi.status.lastStrong != U_LEFT_TO_RIGHT) {
                             // the numbers need to be on a higher embedding level, so let's close that run
-                            bidi.dir = QChar::DirEN;
+                            bidi.dir = U_EUROPEAN_NUMBER;
                             appendRun(bidi);
-                            if (bidi.context->dir() != QChar::DirL) {
+                            if (bidi.context->dir() != U_LEFT_TO_RIGHT) {
                                 // the neutrals take the embedding direction, which is R
                                 bidi.eor = bidi.last;
-                                bidi.dir = QChar::DirR;
+                                bidi.dir = U_RIGHT_TO_LEFT;
                                 appendRun(bidi);
                             }
                         }
-                    } else if (bidi.status.eor == QChar::DirAN) {
+                    } else if (bidi.status.eor == U_ARABIC_NUMBER) {
                         // Arabic numbers are always on a higher embedding level, so let's close that run
-                        bidi.dir = QChar::DirAN;
+                        bidi.dir = U_ARABIC_NUMBER;
                         appendRun(bidi);
-                        if (bidi.context->dir() != QChar::DirL) {
+                        if (bidi.context->dir() != U_LEFT_TO_RIGHT) {
                             // the neutrals take the embedding direction, which is R
                             bidi.eor = bidi.last;
-                            bidi.dir = QChar::DirR;
+                            bidi.dir = U_RIGHT_TO_LEFT;
                             appendRun(bidi);
                         }
-                    } else if(bidi.status.eor != QChar::DirL) {
+                    } else if(bidi.status.eor != U_LEFT_TO_RIGHT) {
                         //last stuff takes embedding dir
-                        if (bidi.context->dir() != QChar::DirL && bidi.status.lastStrong != QChar::DirL) {
+                        if (bidi.context->dir() != U_LEFT_TO_RIGHT && bidi.status.lastStrong != U_LEFT_TO_RIGHT) {
                             bidi.eor = bidi.last; 
-                            bidi.dir = QChar::DirR; 
+                            bidi.dir = U_RIGHT_TO_LEFT; 
                         }
                         appendRun(bidi); 
@@ -1105 +1119 @@
             }
             bidi.eor = bidi.current;
-            bidi.status.eor = QChar::DirL;
-            bidi.status.lastStrong = QChar::DirL;
-            bidi.dir = QChar::DirL;
+            bidi.status.eor = U_LEFT_TO_RIGHT;
+            bidi.status.lastStrong = U_LEFT_TO_RIGHT;
+            bidi.dir = U_LEFT_TO_RIGHT;
             break;
-        case QChar::DirAL:
-        case QChar::DirR:
+        case U_RIGHT_TO_LEFT_ARABIC:
+        case U_RIGHT_TO_LEFT:
             switch (bidi.status.last) {
-                case QChar::DirL:
-                case QChar::DirEN:
-                case QChar::DirAN:
+                case U_LEFT_TO_RIGHT:
+                case U_EUROPEAN_NUMBER:
+                case U_ARABIC_NUMBER:
                     appendRun(bidi);
-                case QChar::DirR:
-                case QChar::DirAL:
+                case U_RIGHT_TO_LEFT:
+                case U_RIGHT_TO_LEFT_ARABIC:
                     break;
-                case QChar::DirES:
-                case QChar::DirET:
-                case QChar::DirCS:
-                case QChar::DirBN:
-                case QChar::DirB:
-                case QChar::DirS:
-                case QChar::DirWS:
-                case QChar::DirON:
-                    if (bidi.status.eor != QChar::DirR && bidi.status.eor != QChar::DirAL) {
+                case U_EUROPEAN_NUMBER_SEPARATOR:
+                case U_EUROPEAN_NUMBER_TERMINATOR:
+                case U_COMMON_NUMBER_SEPARATOR:
+                case U_BOUNDARY_NEUTRAL:
+                case U_BLOCK_SEPARATOR:
+                case U_SEGMENT_SEPARATOR:
+                case U_WHITE_SPACE_NEUTRAL:
+                case U_OTHER_NEUTRAL:
+                    if (bidi.status.eor != U_RIGHT_TO_LEFT && bidi.status.eor != U_RIGHT_TO_LEFT_ARABIC) {
                         //last stuff takes embedding dir
-                        if (bidi.context->dir() != QChar::DirR && bidi.status.lastStrong != QChar::DirR 
-                            && bidi.status.lastStrong != QChar::DirAL) {
+                        if (bidi.context->dir() != U_RIGHT_TO_LEFT && bidi.status.lastStrong != U_RIGHT_TO_LEFT 
+                            && bidi.status.lastStrong != U_RIGHT_TO_LEFT_ARABIC) {
                             bidi.eor = bidi.last;
-                            bidi.dir = QChar::DirL; 
+                            bidi.dir = U_LEFT_TO_RIGHT; 
                         }
                         appendRun(bidi);
@@ -1140 +1154 @@
             }
             bidi.eor = bidi.current;
-            bidi.status.eor = QChar::DirR;
+            bidi.status.eor = U_RIGHT_TO_LEFT;
             bidi.status.lastStrong = dirCurrent;
-            bidi.dir = QChar::DirR;
+            bidi.dir = U_RIGHT_TO_LEFT;
             break;
 
             // weak types:
 
-        case QChar::DirEN:
-            if (bidi.status.lastStrong != QChar::DirAL) {
+        case U_EUROPEAN_NUMBER:
+            if (bidi.status.lastStrong != U_RIGHT_TO_LEFT_ARABIC) {
                 // if last strong was AL change EN to AN
                 switch (bidi.status.last) {
-                    case QChar::DirEN:
-                    case QChar::DirL:
+                    case U_EUROPEAN_NUMBER:
+                    case U_LEFT_TO_RIGHT:
                         break;
-                    case QChar::DirR:
-                    case QChar::DirAL:
-                    case QChar::DirAN:
+                    case U_RIGHT_TO_LEFT:
+                    case U_RIGHT_TO_LEFT_ARABIC:
+                    case U_ARABIC_NUMBER:
                         bidi.eor = bidi.last;
                         appendRun(bidi);
-                        bidi.dir = QChar::DirEN;
+                        bidi.dir = U_EUROPEAN_NUMBER;
                         break;
-                    case QChar::DirES:
-                    case QChar::DirCS:
-                        if (bidi.status.eor == QChar::DirEN)
+                    case U_EUROPEAN_NUMBER_SEPARATOR:
+                    case U_COMMON_NUMBER_SEPARATOR:
+                        if (bidi.status.eor == U_EUROPEAN_NUMBER)
                             break;
-                    case QChar::DirET:
-                    case QChar::DirBN:
-                    case QChar::DirB:
-                    case QChar::DirS:
-                    case QChar::DirWS:
-                    case QChar::DirON:
-                        if (bidi.status.eor == QChar::DirR) {
+                    case U_EUROPEAN_NUMBER_TERMINATOR:
+                    case U_BOUNDARY_NEUTRAL:
+                    case U_BLOCK_SEPARATOR:
+                    case U_SEGMENT_SEPARATOR:
+                    case U_WHITE_SPACE_NEUTRAL:
+                    case U_OTHER_NEUTRAL:
+                        if (bidi.status.eor == U_RIGHT_TO_LEFT) {
                             // neutrals go to R
-                            bidi.eor = bidi.status.last == QChar::DirET ? bidi.lastBeforeET : bidi.last;
+                            bidi.eor = bidi.status.last == U_EUROPEAN_NUMBER_TERMINATOR ? bidi.lastBeforeET : bidi.last;
                             appendRun(bidi);
-                            bidi.dir = QChar::DirEN;
-                        } else if (bidi.status.eor != QChar::DirL &&
-                                 (bidi.status.eor != QChar::DirEN || bidi.status.lastStrong != QChar::DirL) &&
-                                 bidi.dir != QChar::DirL) {
+                            bidi.dir = U_EUROPEAN_NUMBER;
+                        } else if (bidi.status.eor != U_LEFT_TO_RIGHT &&
+                                 (bidi.status.eor != U_EUROPEAN_NUMBER || bidi.status.lastStrong != U_LEFT_TO_RIGHT) &&
+                                 bidi.dir != U_LEFT_TO_RIGHT) {
                             // numbers on both sides, neutrals get right to left direction
                             appendRun(bidi);
-                            bidi.eor = bidi.status.last == QChar::DirET ? bidi.lastBeforeET : bidi.last;
-                            bidi.dir = QChar::DirR;
+                            bidi.eor = bidi.status.last == U_EUROPEAN_NUMBER_TERMINATOR ? bidi.lastBeforeET : bidi.last;
+                            bidi.dir = U_RIGHT_TO_LEFT;
                             appendRun(bidi);
-                            bidi.dir = QChar::DirEN;
+                            bidi.dir = U_EUROPEAN_NUMBER;
                         }
                     default:
@@ -1190 +1204 @@
                 }
                 bidi.eor = bidi.current;
-                bidi.status.eor = QChar::DirEN;
-                if (bidi.dir == QChar::DirON)
-                    bidi.dir = QChar::DirL;
+                bidi.status.eor = U_EUROPEAN_NUMBER;
+                if (bidi.dir == U_OTHER_NEUTRAL)
+                    bidi.dir = U_LEFT_TO_RIGHT;
                 break;
             }
-        case QChar::DirAN:
-            dirCurrent = QChar::DirAN;
+        case U_ARABIC_NUMBER:
+            dirCurrent = U_ARABIC_NUMBER;
             switch (bidi.status.last) {
-                case QChar::DirL:
-                    if (bidi.context->dir() == QChar::DirL)
+                case U_LEFT_TO_RIGHT:
+                    if (bidi.context->dir() == U_LEFT_TO_RIGHT)
                         appendRun(bidi);
                     break;
-                case QChar::DirAN:
+                case U_ARABIC_NUMBER:
                     break;
-                case QChar::DirR:
-                case QChar::DirAL:
-                case QChar::DirEN:
+                case U_RIGHT_TO_LEFT:
+                case U_RIGHT_TO_LEFT_ARABIC:
+                case U_EUROPEAN_NUMBER:
                     bidi.eor = bidi.last;
                     appendRun(bidi);
                     break;
-                case QChar::DirCS:
-                    if (bidi.status.eor == QChar::DirAN)
+                case U_COMMON_NUMBER_SEPARATOR:
+                    if (bidi.status.eor == U_ARABIC_NUMBER)
                         break;
-                case QChar::DirES:
-                case QChar::DirET:
-                case QChar::DirBN:
-                case QChar::DirB:
-                case QChar::DirS:
-                case QChar::DirWS:
-                case QChar::DirON:
-                    if (bidi.status.eor != QChar::DirR && bidi.status.eor != QChar::DirAL) {
+                case U_EUROPEAN_NUMBER_SEPARATOR:
+                case U_EUROPEAN_NUMBER_TERMINATOR:
+                case U_BOUNDARY_NEUTRAL:
+                case U_BLOCK_SEPARATOR:
+                case U_SEGMENT_SEPARATOR:
+                case U_WHITE_SPACE_NEUTRAL:
+                case U_OTHER_NEUTRAL:
+                    if (bidi.status.eor != U_RIGHT_TO_LEFT && bidi.status.eor != U_RIGHT_TO_LEFT_ARABIC) {
                         // run of L before neutrals, neutrals take embedding dir (N2)
-                        if (bidi.context->dir() == QChar::DirR || bidi.status.lastStrong == QChar::DirR 
-                            || bidi.status.lastStrong == QChar::DirAL) { 
+                        if (bidi.context->dir() == U_RIGHT_TO_LEFT || bidi.status.lastStrong == U_RIGHT_TO_LEFT 
+                            || bidi.status.lastStrong == U_RIGHT_TO_LEFT_ARABIC) { 
                             // the embedding direction is R
                             // close the L run
                             appendRun(bidi);
                             // neutrals become an R run
-                            bidi.dir = QChar::DirR;
+                            bidi.dir = U_RIGHT_TO_LEFT;
                         } else {
                             // the embedding direction is L
                             // append neutrals to the L run and close it
-                            bidi.dir = QChar::DirL; 
+                            bidi.dir = U_LEFT_TO_RIGHT; 
                         }
                     }
@@ -1241 +1255 @@
             }
             bidi.eor = bidi.current;
-            bidi.status.eor = QChar::DirAN;
-            if (bidi.dir == QChar::DirON)
-                bidi.dir = QChar::DirAN;
+            bidi.status.eor = U_ARABIC_NUMBER;
+            if (bidi.dir == U_OTHER_NEUTRAL)
+                bidi.dir = U_ARABIC_NUMBER;
             break;
-        case QChar::DirES:
-        case QChar::DirCS:
+        case U_EUROPEAN_NUMBER_SEPARATOR:
+        case U_COMMON_NUMBER_SEPARATOR:
             break;
-        case QChar::DirET:
-            if (bidi.status.last == QChar::DirEN) {
-                dirCurrent = QChar::DirEN;
+        case U_EUROPEAN_NUMBER_TERMINATOR:
+            if (bidi.status.last == U_EUROPEAN_NUMBER) {
+                dirCurrent = U_EUROPEAN_NUMBER;
                 bidi.eor = bidi.current;
                 bidi.status.eor = dirCurrent;
-            } else if (bidi.status.last != QChar::DirET)
+            } else if (bidi.status.last != U_EUROPEAN_NUMBER_TERMINATOR)
                 bidi.lastBeforeET = emptyRun ? bidi.eor : bidi.last;
             break;
 
         // boundary neutrals should be ignored
-        case QChar::DirBN:
+        case U_BOUNDARY_NEUTRAL:
             if (bidi.eor == bidi.last)
                 bidi.eor = bidi.current;
             break;
             // neutrals
-        case QChar::DirB:
+        case U_BLOCK_SEPARATOR:
             // ### what do we do with newline and paragraph seperators that come to here?
             break;
-        case QChar::DirS:
+        case U_SEGMENT_SEPARATOR:
             // ### implement rule L1
             break;
-        case QChar::DirWS:
+        case U_WHITE_SPACE_NEUTRAL:
             break;
-        case QChar::DirON:
+        case U_OTHER_NEUTRAL:
             break;
         default:
@@ -1282 +1296 @@
                     bidi.eor = bidi.endOfLine;
                     switch (bidi.status.eor) {
-                        case QChar::DirL:
-                        case QChar::DirR:
-                        case QChar::DirAN:
+                        case U_LEFT_TO_RIGHT:
+                        case U_RIGHT_TO_LEFT:
+                        case U_ARABIC_NUMBER:
                             bidi.dir = bidi.status.eor;
                             break;
-                        case QChar::DirEN:
-                            bidi.dir = bidi.status.lastStrong == QChar::DirL ? QChar::DirL : QChar::DirEN;
+                        case U_EUROPEAN_NUMBER:
+                            bidi.dir = bidi.status.lastStrong == U_LEFT_TO_RIGHT ? U_LEFT_TO_RIGHT : U_EUROPEAN_NUMBER;
                             break;
                         default:
@@ -1296 +1310 @@
                 }
                 bidi = stateAtEnd;
-                bidi.dir = QChar::DirON;
+                bidi.dir = U_OTHER_NEUTRAL;
                 break;
             }
@@ -1303 +1317 @@
         // set status.last as needed.
         switch (dirCurrent) {
-            case QChar::DirET:
-                if (bidi.status.last != QChar::DirEN)
-                    bidi.status.last = QChar::DirET;
+            case U_EUROPEAN_NUMBER_TERMINATOR:
+                if (bidi.status.last != U_EUROPEAN_NUMBER)
+                    bidi.status.last = U_EUROPEAN_NUMBER_TERMINATOR;
                 break;
-            case QChar::DirES:
-            case QChar::DirCS:
-            case QChar::DirS:
-            case QChar::DirWS:
-            case QChar::DirON:
+            case U_EUROPEAN_NUMBER_SEPARATOR:
+            case U_COMMON_NUMBER_SEPARATOR:
+            case U_SEGMENT_SEPARATOR:
+            case U_WHITE_SPACE_NEUTRAL:
+            case U_OTHER_NEUTRAL:
                 switch(bidi.status.last) {
-                    case QChar::DirL:
-                    case QChar::DirR:
-                    case QChar::DirAL:
-                    case QChar::DirEN:
-                    case QChar::DirAN:
+                    case U_LEFT_TO_RIGHT:
+                    case U_RIGHT_TO_LEFT:
+                    case U_RIGHT_TO_LEFT_ARABIC:
+                    case U_EUROPEAN_NUMBER:
+                    case U_ARABIC_NUMBER:
                         bidi.status.last = dirCurrent;
                         break;
                     default:
-                        bidi.status.last = QChar::DirON;
+                        bidi.status.last = U_OTHER_NEUTRAL;
                     }
                 break;
-            case QChar::DirNSM:
-            case QChar::DirBN:
-            case QChar::DirRLE:
-            case QChar::DirLRE:
-            case QChar::DirRLO:
-            case QChar::DirLRO:
-            case QChar::DirPDF:
+            case U_DIR_NON_SPACING_MARK:
+            case U_BOUNDARY_NEUTRAL:
+            case U_RIGHT_TO_LEFT_EMBEDDING:
+            case U_LEFT_TO_RIGHT_EMBEDDING:
+            case U_RIGHT_TO_LEFT_OVERRIDE:
+            case U_LEFT_TO_RIGHT_OVERRIDE:
+            case U_POP_DIRECTIONAL_FORMAT:
                 // ignore these
                 break;
-            case QChar::DirEN:
+            case U_EUROPEAN_NUMBER:
                 // fall through
             default:
@@ -1341 +1355 @@
         bidi.last = bidi.current;
 
-        if (emptyRun && !(dirCurrent == QChar::DirRLE || dirCurrent == QChar::DirLRE || dirCurrent == QChar::DirRLO || dirCurrent == QChar::DirLRO || dirCurrent == QChar::DirPDF)) {
+        if (emptyRun && !(dirCurrent == U_RIGHT_TO_LEFT_EMBEDDING
+                || dirCurrent == U_LEFT_TO_RIGHT_EMBEDDING
+                || dirCurrent == U_RIGHT_TO_LEFT_OVERRIDE
+                || dirCurrent == U_LEFT_TO_RIGHT_OVERRIDE
+                || dirCurrent == U_POP_DIRECTIONAL_FORMAT)) {
             bidi.sor = bidi.current;
             emptyRun = false;
@@ -1351 +1369 @@
         bidi.current.increment(bidi);
         bidi.adjustEmbedding = false;
-        if (emptyRun && (dirCurrent == QChar::DirRLE || dirCurrent == QChar::DirLRE || dirCurrent == QChar::DirRLO || dirCurrent == QChar::DirLRO || dirCurrent == QChar::DirPDF)) {
+        if (emptyRun && (dirCurrent == U_RIGHT_TO_LEFT_EMBEDDING
+                || dirCurrent == U_LEFT_TO_RIGHT_EMBEDDING
+                || dirCurrent == U_RIGHT_TO_LEFT_OVERRIDE
+                || dirCurrent == U_LEFT_TO_RIGHT_OVERRIDE
+                || dirCurrent == U_POP_DIRECTIONAL_FORMAT)) {
             // exclude the embedding char itself from the new run so that ATSUI will never see it
             bidi.eor.obj = 0;
@@ -1534 +1556 @@
         BidiContext *startEmbed;
         if (style()->direction() == LTR) {
-            startEmbed = new BidiContext( 0, QChar::DirL, NULL, style()->unicodeBidi() == Override );
-            bidi.status.eor = QChar::DirL;
+            startEmbed = new BidiContext( 0, U_LEFT_TO_RIGHT, NULL, style()->unicodeBidi() == Override );
+            bidi.status.eor = U_LEFT_TO_RIGHT;
         } else {
-            startEmbed = new BidiContext( 1, QChar::DirR, NULL, style()->unicodeBidi() == Override );
-            bidi.status.eor = QChar::DirR;
+            startEmbed = new BidiContext( 1, U_RIGHT_TO_LEFT, NULL, style()->unicodeBidi() == Override );
+            bidi.status.eor = U_RIGHT_TO_LEFT;
         }
 
@@ -1545 +1567 @@
         bidi.status.eor = startEmbed->dir();
         bidi.context = startEmbed;
-        bidi.dir = QChar::DirON;
+        bidi.dir = U_OTHER_NEUTRAL;
         
         if (!smidpoints)
@@ -1874 +1896 @@
 static inline bool skipNonBreakingSpace(BidiIterator &it)
 {
-    if (it.obj->style()->nbspMode() != SPACE || it.current().unicode() != nonBreakingSpace)
+    if (it.obj->style()->nbspMode() != SPACE || it.current() != nonBreakingSpace)
         return false;
  
@@ -1902 +1924 @@
     while (!it.atEnd() && (it.obj->isInlineFlow() || (shouldCollapseWhiteSpace(it.obj->style()) && !it.obj->isBR() &&
           (it.current() == ' ' || it.current() == '\t' || (!it.obj->style()->preserveNewline() && it.current() == '\n') ||
-          it.current().unicode() == SOFT_HYPHEN || skipNonBreakingSpace(it) || it.obj->isFloatingOrPositioned())))) {
+          it.current() == SOFT_HYPHEN || skipNonBreakingSpace(it) || it.obj->isFloatingOrPositioned())))) {
         if (it.obj->isFloatingOrPositioned()) {
             RenderObject *o = it.obj;
@@ -2103 +2125 @@
                 if (style()->collapseWhiteSpace() && next && !next->isBR() && next->isText() && static_cast<RenderText*>(next)->stringLength() > 0) {
                     RenderText *nextText = static_cast<RenderText*>(next);
-                    QChar nextChar = nextText->text()[0];
-
+                    UChar nextChar = nextText->text()[0];
                     if (nextText->style()->isCollapsibleWhiteSpace(nextChar)) {
                         currentCharacterIsSpace = true;
@@ -2119 +2140 @@
             int strlen = t->stringLength();
             int len = strlen - pos;
-            const QChar* str = t->text();
+            const UChar* str = t->text();
 
             const Font *f = t->font(m_firstLine);
@@ -2135 +2156 @@
                 bool previousCharacterIsSpace = currentCharacterIsSpace;
                 bool previousCharacterIsWS = currentCharacterIsWS;
-                const QChar c = str[pos];
+                UChar c = str[pos];
                 currentCharacterIsSpace = c == ' ' || c == '\t' || (!o->style()->preserveNewline() && (c == '\n'));
 
@@ -2142 +2163 @@
                 
                 // Check for soft hyphens.  Go ahead and ignore them.
-                if (c.unicode() == SOFT_HYPHEN) {
+                if (c == SOFT_HYPHEN) {
                     if (!ignoringSpaces) {
                         // Ignore soft hyphens
@@ -2182 +2203 @@
                 bool breakWords = o->style()->wordWrap() == BREAK_WORD && ((allowBreak && w == 0) || o->style()->whiteSpace() == PRE);
 
-                currentCharacterIsWS = currentCharacterIsSpace || (breakNBSP && c.unicode() == nonBreakingSpace);
+                currentCharacterIsWS = currentCharacterIsSpace || (breakNBSP && c == nonBreakingSpace);
 
                 if (breakWords)
@@ -2267 +2288 @@
                             if (midWordBreak)
                                 tmpW -= additionalTmpW;
-                            if (pos > 0 && str[pos-1].unicode() == SOFT_HYPHEN)
+                            if (pos > 0 && str[pos-1] == SOFT_HYPHEN)
                                 // Subtract the width of the soft hyphen out since we fit on a line.
                                 tmpW -= t->width(pos-1, 1, f, w+tmpW);
@@ -2370 +2391 @@
                     RenderText* nextText = static_cast<RenderText*>(next);
                     if (nextText->stringLength() != 0) {
-                        QChar c = nextText->text()[0];
-                        if (c == ' ' || c == '\t' || (c == '\n' && !next->style()->preserveNewline())) {
+                        UChar c = nextText->text()[0];
+                        if (c == ' ' || c == '\t' || (c == '\n' && !next->style()->preserveNewline()))
                             // If the next item on the line is text, and if we did not end with
                             // a space, then the next text run continues our word (and so it needs to
                             // keep adding to |tmpW|.  Just update and continue.
                             checkForBreak = true;
-                        }
                     }
                     bool canPlaceOnLine = (w + tmpW <= width) || !autoWrap;
@@ -2509 +2529 @@
         // For soft hyphens on line breaks, we have to chop out the midpoints that made us
         // ignore the hyphen so that it will render at the end of the line.
-        QChar c = static_cast<RenderText*>(lBreak.obj)->text()[lBreak.pos-1];
-        if (c.unicode() == SOFT_HYPHEN)
+        UChar c = static_cast<RenderText*>(lBreak.obj)->text()[lBreak.pos-1];
+        if (c == SOFT_HYPHEN)
             chopMidpointsAt(lBreak.obj, lBreak.pos-2);
     }
@@ -2539 +2559 @@
 {
     // Determine the width of the ellipsis using the current font.
-    QChar ellipsis = 0x2026; // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if 0x2026 not renderable
-    static AtomicString ellipsisStr(ellipsis);
+    const UChar ellipsis = 0x2026; // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if 0x2026 not renderable
+    static AtomicString ellipsisStr(&ellipsis, 1);
     const Font& firstLineFont = firstLineStyle()->font();
     const Font& font = style()->font();

trunk/WebCore/rendering/bidi.h

@@ -21 +21 @@
  *
  */
+
 #ifndef BIDI_H
 #define BIDI_H
 
-#include "DeprecatedString.h"
+#include <unicode/uchar.h>
 
 class RenderArena;
 
 namespace WebCore {
+
     class RenderBlock;
     class RenderObject;
@@ -34 +36 @@
 
     struct BidiStatus {
-        BidiStatus() : eor(QChar::DirON), lastStrong(QChar::DirON), last(QChar::DirON) {}
+        BidiStatus() : eor(U_OTHER_NEUTRAL), lastStrong(U_OTHER_NEUTRAL), last(U_OTHER_NEUTRAL) {}
         
-        QChar::Direction eor;
-        QChar::Direction lastStrong;
-        QChar::Direction last;
+        UCharDirection eor;
+        UCharDirection lastStrong;
+        UCharDirection last;
     };
         
     class BidiContext {
     public:
-        BidiContext(unsigned char level, QChar::Direction embedding, BidiContext *parent = 0, bool override = false);
+        BidiContext(unsigned char level, UCharDirection embedding, BidiContext* parent = 0, bool override = false);
         ~BidiContext();
 
@@ -49 +51 @@
         void deref() const;
 
-        QChar::Direction dir() const { return static_cast<QChar::Direction>(m_dir); }
-        QChar::Direction basicDir() const { return static_cast<QChar::Direction>(m_basicDir); }
+        UCharDirection dir() const { return static_cast<UCharDirection>(m_dir); }
+        UCharDirection basicDir() const { return static_cast<UCharDirection>(m_basicDir); }
 
         unsigned char level;
         bool override : 1;
-        unsigned m_dir : 5; // QChar::Direction
-        unsigned m_basicDir : 5; // QChar::Direction
-        
-        BidiContext *parent;
+        unsigned m_dir : 5; // UCharDirection
+        unsigned m_basicDir : 5; // UCharDirection
+
+        BidiContext* parent;
 
         // refcounting....
@@ -64 +66 @@
 
     struct BidiRun {
-        BidiRun(int _start, int _stop, RenderObject *_obj, BidiContext *context, QChar::Direction dir)
-            :  start( _start ), stop( _stop ), obj( _obj ), box(0), override(context->override), nextRun(0)
+        BidiRun(int start_, int stop_, RenderObject* o, BidiContext* context, UCharDirection dir)
+            :  start(start_), stop(stop_), obj(o), box(0), override(context->override), nextRun(0)
         {
-            if (dir == QChar::DirON) 
+            if (dir == U_OTHER_NEUTRAL) 
                 dir = context->dir();
 
@@ -73 +75 @@
 
             // add level of run (cases I1 & I2)
-            if( level % 2 ) {
-                if(dir == QChar::DirL || dir == QChar::DirAN || dir == QChar::DirEN)
+            if (level % 2) {
+                if(dir == U_LEFT_TO_RIGHT || dir == U_ARABIC_NUMBER || dir == U_EUROPEAN_NUMBER)
                     level++;
             } else {
-                if( dir == QChar::DirR )
+                if (dir == U_RIGHT_TO_LEFT)
                     level++;
-                else if( dir == QChar::DirAN || dir == QChar::DirEN)
+                else if (dir == U_ARABIC_NUMBER || dir == U_EUROPEAN_NUMBER)
                     level += 2;
             }
         }
 
-        void destroy(RenderArena* renderArena);
+        void destroy(RenderArena*);
 
         // Overloaded new operator.
-        void* operator new(size_t sz, RenderArena* renderArena) throw();
+        void* operator new(size_t, RenderArena*) throw();
 
         // Overridden to prevent the normal delete from being called.
-        void operator delete(void* ptr, size_t sz);
+        void operator delete(void*, size_t);
 
 private:
         // The normal operator new is disallowed.
-        void* operator new(size_t sz) throw();
+        void* operator new(size_t) throw();
 
 public:

trunk/WebCore/rendering/break_lines.cpp

@@ -32 +32 @@
 namespace WebCore {
 
-int nextBreakablePosition(const QChar *str, int pos, int len, bool breakNBSP)
+int nextBreakablePosition(const UChar* str, int pos, int len, bool breakNBSP)
 {
 #if __APPLE__
@@ -42 +42 @@
     unsigned short ch, lastCh;
     
-    lastCh = pos > 0 ? str[pos - 1].unicode() : 0;
+    lastCh = pos > 0 ? str[pos - 1] : 0;
     for (i = pos; i < len; i++) {
-        ch = str[i].unicode();
+        ch = str[i];
         if (ch == ' ' || ch == '\n' || ch == '\t' || (breakNBSP && ch == 0xa0))
             break;

trunk/WebCore/rendering/break_lines.h

@@ -21 +21 @@
  */
 
-class QChar;
+#include <unicode/umachine.h>
 
 namespace WebCore {
 
-    int nextBreakablePosition(const QChar *str, int pos, int len, bool breakNBSP = false);
+    int nextBreakablePosition(const UChar*, int pos, int len, bool breakNBSP = false);
 
-    inline bool isBreakable(const QChar *str, int pos, int len, int &nextBreakable, bool breakNBSP = false)
+    inline bool isBreakable(const UChar* str, int pos, int len, int& nextBreakable, bool breakNBSP = false)
     {
         if (pos > nextBreakable)

trunk/WebCore/rendering/render_form.cpp

@@ -258 +258 @@
         String widgetText = w->text();
         String newText = e->value();
-        newText.replace(QChar('\\'), backslashAsCurrencySymbol());
+        newText.replace('\\', backslashAsCurrencySymbol());
         if (widgetText != newText) {
             int pos = w->cursorPosition();
@@ -653 +653 @@
                 HTMLOptGroupElement *optgroupElement = static_cast<HTMLOptGroupElement*>(listItems[listIndex]);
                 DeprecatedString label = optgroupElement->getAttribute(labelAttr).deprecatedString();
-                label.replace(QChar('\\'), backslashAsCurrencySymbol());
+                label.replace('\\', backslashAsCurrencySymbol());
                 
                 // In WinIE, an optgroup can't start or end with whitespace (other than the indent
@@ -676 +676 @@
                     itemText = optionElement->text().deprecatedString();
                 
-                itemText.replace(QChar('\\'), backslashAsCurrencySymbol());
+                itemText.replace('\\', backslashAsCurrencySymbol());
 
                 // In WinIE, leading and trailing whitespace is ignored in options. We match this behavior.
@@ -996 +996 @@
     String widgetText = text();
     String text = e->value();
-    text.replace(QChar('\\'), backslashAsCurrencySymbol());
+    text.replace('\\', backslashAsCurrencySymbol());
     if (widgetText != text) {
         int line, col;
@@ -1015 +1015 @@
 {
     String txt = static_cast<QTextEdit*>(m_widget)->text();
-    return txt.replace(backslashAsCurrencySymbol(), QChar('\\'));
+    return txt.replace(backslashAsCurrencySymbol(), '\\');
 }
 
@@ -1021 +1021 @@
 {
     String txt = static_cast<QTextEdit*>(m_widget)->textWithHardLineBreaks();
-    return txt.replace(backslashAsCurrencySymbol(), QChar('\\'));
+    return txt.replace(backslashAsCurrencySymbol(), '\\');
 }
 

trunk/WebCore/rendering/render_line.cpp

@@ -476 +476 @@
             RenderText *rt = static_cast<RenderText*>(text->object());
             if (rt->length()) {
-                if (needsWordSpacing && rt->text()[text->start()].isSpace())
+                if (needsWordSpacing && QChar(rt->text()[text->start()]).isSpace())
                     x += rt->font(m_firstLine)->wordSpacing();
-                needsWordSpacing = !rt->text()[text->end()].isSpace();
+                needsWordSpacing = !QChar(rt->text()[text->end()]).isSpace();
             }
             text->setXPos(x);
@@ -1086 +1086 @@
 
     const String& str = m_str;
-    p->drawText(IntPoint(m_x + _tx, m_y + _ty + m_baseline), 0, 0, str.unicode(), str.length(),
+    p->drawText(IntPoint(m_x + _tx, m_y + _ty + m_baseline), 0, 0, str.characters(), str.length(),
         0, str.length(), 0, LTR, _style->visuallyOrdered(), 0, str.length());
 

trunk/WebCore/rendering/render_list.cpp

@@ -41 +41 @@
 const int cMarkerPadding = 7;
 
-static DeprecatedString toRoman( int number, bool upper )
+static DeprecatedString toRoman(int number, bool upper)
 {
     DeprecatedString roman;
-    QChar ldigits[] = { 'i', 'v', 'x', 'l', 'c', 'd', 'm' };
-    QChar udigits[] = { 'I', 'V', 'X', 'L', 'C', 'D', 'M' };
-    QChar *digits = upper ? udigits : ldigits;
-    int i, d = 0;
-
-    do
-    {
+    const UChar ldigits[] = { 'i', 'v', 'x', 'l', 'c', 'd', 'm' };
+    const UChar udigits[] = { 'I', 'V', 'X', 'L', 'C', 'D', 'M' };
+    const UChar* digits = upper ? udigits : ldigits;
+    int d = 0;
+    do {
         int num = number % 10;
-
-        if ( num % 5 < 4 )
-            for ( i = num % 5; i > 0; i-- )
-                roman.insert( 0, digits[ d ] );
-
-        if ( num >= 4 && num <= 8)
-            roman.insert( 0, digits[ d+1 ] );
-
-        if ( num == 9 )
-            roman.insert( 0, digits[ d+2 ] );
-
-        if ( num % 5 == 4 )
-            roman.insert( 0, digits[ d ] );
-
+        if (num % 5 < 4)
+            for (int i = num % 5; i > 0; i--)
+                roman.insert(0, digits[d]);
+        if (num >= 4 && num <= 8)
+            roman.insert(0, digits[d + 1]);
+        if (num == 9)
+            roman.insert(0, digits[d + 2]);
+        if (num % 5 == 4)
+            roman.insert(0, digits[d]);
         number /= 10;
         d += 2;
-    }
-    while ( number );
-
+    } while (number);
     return roman;
 }
@@ -77 +68 @@
 {
     if (number < 2)
-        return (QChar)letterA; // match WinIE (A.) not FireFox (0.)
-    
+        return QChar(letterA); // match WinIE (A.) not FireFox (0.)
+
     DeprecatedString letterString;
     while (number > 0) {
-        int onesDigit = ((number - 1) % 26);
-        letterString = (QChar)(letterA + onesDigit) + letterString;
+        int onesDigit = (number - 1) % 26;
+        letterString = QChar(letterA + onesDigit) + letterString;
         number -= onesDigit;
         number /= 26;
     }
-    
+
     return letterString;
 }
 
-static DeprecatedString toHebrew( int number ) {
+static DeprecatedString toHebrew(int number)
+{
     const QChar tenDigit[] = {1497, 1499, 1500, 1502, 1504, 1505, 1506, 1508, 1510};
 
     DeprecatedString letter;
     if (number > 999) {
-        letter = toHebrew(number/1000) + "'";
+        letter = toHebrew(number / 1000) + "'";
         number = number % 1000;
     }
-
-    int hunderts = (number/400);
-    if (hunderts > 0) {
-        for (int i=0; i<hunderts; i++)
-            letter += QChar(1511 + 3);
-    }
-    number = number % 400;
-    if ((number / 100) != 0)
-        letter += QChar (1511 + (number / 100) -1);
-    number = number % 100;
-    int tens = number/10;
-    if (tens > 0 && !(number == 15 || number == 16))
-        letter += tenDigit[tens-1];
-    if (number == 15 || number == 16) { // special because of religious
-        letter += QChar(1487 + 9);       // reasons
+    int fourHundreds = number / 400;
+    for (int i = 0; i < fourHundreds; i++)
+        letter += QChar(1511 + 3);
+    number %= 400;
+    if (number / 100)
+        letter += QChar(1511 + (number / 100) - 1);
+    number %= 100;
+    if (number == 15 || number == 16) {
+        letter += QChar(1487 + 9);
         letter += QChar(1487 + number - 9);
     } else {
+        int tens = number / 10;
+        if (tens)
+            letter += tenDigit[tens - 1];
         number = number % 10;
-        if (number != 0)
-            letter += QChar (1487 + number);
+        if (number)
+            letter += QChar(1487 + number);
     }
     return letter;
@@ -128 +117 @@
 {
     // init RenderObject attributes
-    setInline(false);   // our object is not Inline
+    setInline(false); // our object is not Inline
 }
 
@@ -292 +281 @@
 }
 
-void RenderListItem::layout( )
-{
-    KHTMLAssert( needsLayout() );
-    KHTMLAssert( minMaxKnown() );
+void RenderListItem::layout()
+{
+    KHTMLAssert(needsLayout());
+    KHTMLAssert(minMaxKnown());
     
     updateMarkerLocation();    
@@ -453 +442 @@
         if (!m_item.isEmpty()) {
             const Font& font = style()->font();
-            if( style()->direction() == LTR) {
-                p->drawText(marker.location(), AlignLeft, m_item);
-                p->drawText(marker.location() + IntSize(font.width(m_item), 0), AlignLeft, ". ");
+            if (style()->direction() == LTR) {
+                int width = font.width(reinterpret_cast<const UChar*>(m_item.unicode()), m_item.length());
+                p->drawText(marker.location(), m_item);
+                p->drawText(marker.location() + IntSize(width, 0), ". ");
             } else {
-                p->drawText(marker.location(), AlignLeft, " .");
-                p->drawText(marker.location() + IntSize(font.width(" ."), 0), AlignLeft, m_item);
+                UChar spacePeriod[2] = { '.', ' ' };
+                int width = font.width(spacePeriod, 2);
+                p->drawText(marker.location(), " .");
+                p->drawText(marker.location() + IntSize(width, 0), m_item);
             }
         }
@@ -557 +549 @@
     }
 
-    m_width = font.width(m_item) + font.width(". ");
+    {
+        int itemWidth = font.width(reinterpret_cast<const UChar*>(m_item.unicode()), m_item.length());
+        UChar periodSpace[2] = { '.', ' ' };
+        int periodSpaceWidth = font.width(periodSpace, 2);
+        m_width = itemWidth + periodSpaceWidth;
+    }
 
 end:
@@ -679 +676 @@
         case LNONE:
             return IntRect();
-        default:
-            if (m_item.isEmpty())
-                return IntRect();
-            return IntRect(m_x, m_y + ascent, font.width(m_item) + font.width(". "), font.height());
-    }
+        case ARMENIAN:
+        case CJK_IDEOGRAPHIC:
+        case DECIMAL_LEADING_ZERO:
+        case GEORGIAN:
+        case HEBREW:
+        case HIRAGANA:
+        case HIRAGANA_IROHA:
+        case KATAKANA:
+        case KATAKANA_IROHA:
+        case LDECIMAL:
+        case LOWER_ALPHA:
+        case LOWER_GREEK:
+        case LOWER_LATIN:
+        case LOWER_ROMAN:
+        case UPPER_ALPHA:
+        case UPPER_LATIN:
+        case UPPER_ROMAN:
+            break;
+    }
+
+    if (m_item.isEmpty())
+        return IntRect();
+
+    int itemWidth = font.width(reinterpret_cast<const UChar*>(m_item.unicode()), m_item.length());
+    UChar periodSpace[2] = { '.', ' ' };
+    int periodSpaceWidth = font.width(periodSpace, 2);
+    return IntRect(m_x, m_y + ascent, itemWidth + periodSpaceWidth, font.height());
 }
 

trunk/WebCore/rendering/render_style.cpp

@@ -630 +630 @@
                   FIRST_LETTER_BIT = 0x8, SELECTION_BIT = 0x10, FIRST_LINE_INHERITED_BIT = 0x20 };
 
-static int pseudoBit(RenderStyle::PseudoId pseudo)
+static inline int pseudoBit(RenderStyle::PseudoId pseudo)
 {
     switch (pseudo) {
@@ -652 +652 @@
 bool RenderStyle::hasPseudoStyle(PseudoId pseudo) const
 {
-    return (pseudoBit(pseudo) & noninherited_flags._pseudoBits) != 0;
+    return pseudoBit(pseudo) & noninherited_flags._pseudoBits;
 }
 
@@ -662 +662 @@
 RenderStyle* RenderStyle::getPseudoStyle(PseudoId pid)
 {
-    if (!pseudoStyle)
-        return 0;
-
-    RenderStyle *ps = 0;
-    if (noninherited_flags._styleType==NOPSEUDO) {
-        ps = pseudoStyle;
-        while (ps) {
-            if (styleType() == pid)
-                    break;
-    
-            ps = ps->pseudoStyle;
-        }
-    }
+    RenderStyle* ps = 0;
+    if (noninherited_flags._styleType == NOPSEUDO)
+        for (ps = pseudoStyle; ps; ps = ps->psuedoStyle)
+            if (ps->styleType() == pid)
+                break;
     return ps;
 }
@@ -680 +672 @@
 void RenderStyle::addPseudoStyle(RenderStyle* pseudo)
 {
-    if (!pseudo) return;
+    if (!pseudo)
+        return;
     pseudo->ref();
     pseudo->pseudoStyle = pseudoStyle;

trunk/WebCore/rendering/render_style.h

@@ -1237 +1237 @@
         return collapseWhiteSpace(whiteSpace());
     }
-    bool isCollapsibleWhiteSpace(const QChar& c) const {
-        switch (c.unicode()) {
+    bool isCollapsibleWhiteSpace(UChar c) const {
+        switch (c) {
             case ' ':
             case '\t':

trunk/WebCore/xml/XSLStyleSheet.cpp

@@ -120 +120 @@
 {
     // Parse in a single chunk into an xmlDocPtr
-    const QChar BOM(0xFEFF);
+    const UChar BOM(0xFEFF);
     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);
     setLoaderForLibXMLCallbacks(docLoader());
@@ -126 +126 @@
         xmlFreeDoc(m_stylesheetDoc);
     m_stylesheetDocTaken = false;
-    m_stylesheetDoc = xmlReadMemory(reinterpret_cast<const char *>(string.unicode()), string.length() * sizeof(QChar),
+    m_stylesheetDoc = xmlReadMemory(reinterpret_cast<const char*>(string.characters()), string.length() * sizeof(UChar),
         m_ownerDocument->URL().ascii(),
         BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE", 

trunk/WebCore/xml/xmlhttprequest.cpp

@@ -86 +86 @@
     unsigned length = contentTypeString.length();
     for (unsigned offset = 0; offset < length; offset++) {
-        QChar c = contentTypeString[offset];
+        UChar c = contentTypeString[offset];
         if (c == ';')
             break;
-        else if (c.isSpace()) // FIXME: This seems wrong, " " is an invalid MIME type character according to RFC 2045.  bug 8644
+        else if (QChar(c).isSpace()) // FIXME: This seems wrong, " " is an invalid MIME type character according to RFC 2045.  bug 8644
             continue;
-        mimeType += String(c);
+        // FIXME: This is a very slow way to build a string, given WebCore::String's implementation.
+        mimeType += String(&c, 1);
     }
     return mimeType;
@@ -107 +108 @@
         
         // is what we found a beginning of a word?
-        if (contentTypeString[pos-1].unicode() > ' ' && contentTypeString[pos-1] != ';') {
+        if (contentTypeString[pos-1] > ' ' && contentTypeString[pos-1] != ';') {
             pos += 7;
             continue;
@@ -115 +116 @@
 
         // skip whitespace
-        while (pos != length && contentTypeString[pos].unicode() <= ' ')
+        while (pos != length && contentTypeString[pos] <= ' ')
             ++pos;
     
@@ -121 +122 @@
             continue;
 
-        while (pos != length && (contentTypeString[pos].unicode() <= ' ' || contentTypeString[pos] == '"' || contentTypeString[pos] == '\''))
+        while (pos != length && (contentTypeString[pos] <= ' ' || contentTypeString[pos] == '"' || contentTypeString[pos] == '\''))
             ++pos;
 
         // we don't handle spaces within quoted parameter values, because charset names cannot have any
         int endpos = pos;
-        while (pos != length && contentTypeString[endpos].unicode() > ' ' && contentTypeString[endpos] != '"' && contentTypeString[endpos] != '\'' && contentTypeString[endpos] != ';')
+        while (pos != length && contentTypeString[endpos] > ' ' && contentTypeString[endpos] != '"' && contentTypeString[endpos] != '\'' && contentTypeString[endpos] != ';')
             ++endpos;
     

trunk/WebCore/xpath/impl/XPathExpressionNode.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
 #if XPATH_SUPPORT
 
+#include "XPathExpressionNode.h"
+
 #include "Logging.h"
-#include "XPathExpressionNode.h"
 #include "Node.h"
-
-#include <cmath>
+#include "XPathValue.h"
+#include <math.h>
 
 using namespace std;
@@ -53 +55 @@
 {
     deleteAllValues(m_subExpressions);
-    
     delete m_constantValue;
 }
@@ -61 +62 @@
     if (m_constantValue)
         return *m_constantValue;
-
     return doEvaluate();
 }
@@ -89 +89 @@
 }
 
-unsigned int Expression::subExprCount() const
+unsigned Expression::subExprCount() const
 {
     return m_subExpressions.size();
@@ -97 +97 @@
 {
     ASSERT(i < subExprCount());
-
     return m_subExpressions[i];
 }
@@ -104 +103 @@
 {
     ASSERT(i < subExprCount());
-    
     return m_subExpressions[i];
 }
@@ -110 +108 @@
 bool Expression::isConstant() const
 {
-    for (unsigned i = 0; i < m_subExpressions.size(); i++) {
+    for (unsigned i = 0; i < m_subExpressions.size(); i++)
         if (!m_subExpressions[i]->isConstant())
             return false;
-    }
-
     return true;
 }

trunk/WebCore/xpath/impl/XPathExpressionNode.h

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #ifndef XPathExpressionNode_H
 #define XPathExpressionNode_H
 
 #if XPATH_SUPPORT
-
-#include "XPathValue.h"
 
 #include "StringHash.h"
@@ -36 +35 @@
 
 namespace WebCore {
+
+class Node;
 class XPathNSResolver;
 
 namespace XPath {
+
+class Value;
         
-struct EvaluationContext
-{
+struct EvaluationContext {
     EvaluationContext() : node(0), size(0), position(0), resolver(0) { }
 
@@ -55 +57 @@
 };
 
-class ParseNode
-{
+class ParseNode {
+public:
+    virtual ~ParseNode() { }
 };
 
@@ -66 +69 @@
     Expression();
     virtual ~Expression();
+
     virtual Value evaluate() const;
 
-    void addSubExpression(Expression* expr);
+    void addSubExpression(Expression*);
     void optimize();
     virtual bool isConstant() const;
 
 protected:
-    unsigned int subExprCount() const;
+    unsigned subExprCount() const;
     Expression* subExpr(unsigned i);
     const Expression* subExpr(unsigned i) const;

trunk/WebCore/xpath/impl/XPathFunctions.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
@@ -30 +31 @@
 #include "XPathFunctions.h"
 
+#include "DeprecatedString.h"
 #include "Logging.h"
 #include "NamedAttrMap.h"
 #include "Node.h"
-
+#include "XPathValue.h"
 #include <math.h>
 
@@ -325 +327 @@
         s += "-Infinity";
     else
-        s += DeprecatedString::number(m_min);
+        s += String::number(m_min);
 
     s += "..";
@@ -332 +334 @@
         s += "Infinity";
     else
-        s += DeprecatedString::number(m_max);
+        s += String::number(m_max);
 
     s += "]";
@@ -374 +376 @@
 Value FunLast::doEvaluate() const
 {
-    return double(Expression::evaluationContext().size);
+    return Expression::evaluationContext().size;
 }
 
@@ -384 +386 @@
 Value FunPosition::doEvaluate() const
 {
-    return double(Expression::evaluationContext().position);
+    return Expression::evaluationContext().position;
 }
 
@@ -468 +470 @@
     }
     
-    return double(a.toNodeVector().size());
+    return a.toNodeVector().size();
 }
 
@@ -478 +480 @@
 Value FunString::doEvaluate() const
 {
-    if (argCount() == 0) {
-        String s = Value(Expression::evaluationContext().node).toString();
-        return s;
-    }
+    if (argCount() == 0)
+        return Value(Expression::evaluationContext().node).toString();
     return arg(0)->evaluate().toString();
 }
@@ -487 +487 @@
 Value FunConcat::doEvaluate() const
 {
-    String str;
-
-    for (unsigned int i = 0; i < argCount(); ++i)
+    String str = "";
+
+    for (unsigned i = 0; i < argCount(); ++i)
         str += arg(i)->evaluate().toString();
 
@@ -545 +545 @@
         return "";
 
-    return Value(s1.deprecatedString().mid(i + 1));
+    return s1.substring(i + 1);
 }
 
@@ -567 +567 @@
     }
 
-    return Value(s.deprecatedString().mid(pos - 1, len));
+    return s.substring(pos - 1, len);
 }
 
 Value FunStringLength::doEvaluate() const
 {
-    if (argCount() == 0) {
-        String s = Value(Expression::evaluationContext().node).toString();
-        return double(s.length());
-    }
-
-    return double(arg(0)->evaluate().toString().length());
+    if (argCount() == 0)
+        return Value(Expression::evaluationContext().node).toString().length();
+    return arg(0)->evaluate().toString().length();
 }
 
@@ -598 +595 @@
     String newString;
 
+    // FIXME: Building a String a character at a time is quite slow.
     for (unsigned i1 = 0; i1 < s1.length(); ++i1) {
-        QChar ch = s1[i1];
+        UChar ch = s1[i1];
         int i2 = s2.find(ch);
         
-        if (i2 == -1) 
-            newString += ch;
-        else if ((unsigned)i2 < s3.length())
-            newString += s3[ i2 ];
+        if (i2 == -1)
+            newString += String(&ch, 1);
+        else if ((unsigned)i2 < s3.length()) {
+            UChar c2 = s3[i2];
+            newString += String(&c2, 1);
+        }
     }
 
@@ -696 +696 @@
     
     for (unsigned i = 0; i < nodes.size(); i++)
-        sum += Value(stringValue(nodes[i].get()).deprecatedString()).toNumber();
+        sum += Value(stringValue(nodes[i].get())).toNumber();
     
     return sum;

trunk/WebCore/xpath/impl/XPathGrammar.y

@@ +1 @@
+/*
+ * Copyright 2005 Frerich Raabe <raabe@kde.org>
+ * Copyright (C) 2006 Apple Computer, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 %{
 #include "config.h"
 
+#include "DeprecatedString.h"
+#include "ExceptionCode.h"
+#include "XPathEvaluator.h"
+#include "XPathFunctions.h"
+#include "XPathNSResolver.h"
 #include "XPathParser.h"
-#include "XPathFunctions.h"
 #include "XPathPath.h"
+#include "XPathPredicate.h"
 #include "XPathStep.h"
-#include "XPathPredicate.h"
 #include "XPathUtil.h"
 #include "XPathVariableReference.h"
-    
-#include "XPathNSResolver.h"
-#include "XPathEvaluator.h"
-#include "ExceptionCode.h"
 
 #define YYDEBUG 0

trunk/WebCore/xpath/impl/XPathParser.cpp

@@ -29 +29 @@
 
 #include "XPathParser.h"
+
+#include "DeprecatedString.h"
 #include "XPathEvaluator.h"
 
@@ -36 +38 @@
 #include "XPathGrammar.h"    
 
-struct AxisNameMapping
-{
+struct AxisNameMapping {
     const char* name;
     Step::AxisType type;
@@ -58 +59 @@
 };
 
-static unsigned int axisNamesCount = sizeof(axisNames) / sizeof(axisNames[0]);
+static unsigned axisNamesCount = sizeof(axisNames) / sizeof(axisNames[0]);
 static const char* const nodeTypeNames[] = {
     "comment",
@@ -72 +73 @@
 Parser* Parser::currentParser = 0;
 
-Parser::XMLCat Parser::charCat(QChar aChar)
+Parser::XMLCat Parser::charCat(UChar aChar)
 {
     //### might need to add some special cases from the XML spec.
 
-    if (aChar.unicode() == '_')
+    if (aChar == '_')
         return NameStart;
 
-    if (aChar.unicode() == '.' || aChar.unicode() == '-')
+    if (aChar == '.' || aChar == '-')
         return NameCont;
-    switch (u_charType(aChar.unicode())) {
+    switch (u_charType(aChar)) {
         case U_LOWERCASE_LETTER: //Ll
         case U_UPPERCASE_LETTER: //Lu
@@ -99 +100 @@
 }
 
-bool Parser::isAxisName(String name, Step::AxisType& type)
+bool Parser::isAxisName(const String& name, Step::AxisType& type)
 {
     if (!s_axisNamesDict) {
         s_axisNamesDict = new HashMap<String, Step::AxisType>;
-        for (unsigned int p = 0; p < axisNamesCount; ++p)
-            s_axisNamesDict->set(axisNames[p].name,
-                                 axisNames[p].type);
+        for (unsigned p = 0; p < axisNamesCount; ++p)
+            s_axisNamesDict->set(axisNames[p].name, axisNames[p].type);
     }
 
     HashMap<String, Step::AxisType>::iterator it = s_axisNamesDict->find(name);
-    
-    if (it != s_axisNamesDict->end()) {
-        type = it->second;
-        return true;
-    } else    
+
+    if (it == s_axisNamesDict->end())
         return false;
-}
-
-bool Parser::isNodeTypeName(String name)
+    type = it->second;
+    return true;
+}
+
+bool Parser::isNodeTypeName(const String& name)
 {
     if (!s_nodeTypeNamesDict) {
@@ -149 +148 @@
 void Parser::skipWS()
 {
-    while (m_nextPos < m_data.length() && m_data[m_nextPos].isSpace())
+    while (m_nextPos < m_data.length() && QChar(m_data[m_nextPos]).isSpace())
         ++m_nextPos;
 }
@@ -165 +164 @@
 }
 
-//Returns next char if it's there and interesting, 0 otherwise
+// Returns next char if it's there and interesting, 0 otherwise
 char Parser::peekAheadHelper()
 {
     if (m_nextPos + 1 >= m_data.length())
         return 0;
-    QChar next = m_data[m_nextPos + 1];
-    if (next.unicode() >= 0xff)
+    UChar next = m_data[m_nextPos + 1];
+    if (next >= 0xff)
         return 0;
-
-    return next.unicode();
+    return next;
 }
 
@@ -181 +179 @@
     if (m_nextPos >= m_data.length())
         return 0;
-    QChar next = m_data[m_nextPos];
-    if (next.unicode() >= 0xff)
+    UChar next = m_data[m_nextPos];
+    if (next >= 0xff)
         return 0;
-
-    return next.unicode();
+    return next;
 }
 
 Token Parser::lexString()
 {
-    QChar delimiter = m_data[m_nextPos];
+    UChar delimiter = m_data[m_nextPos];
     int   startPos  = m_nextPos + 1;
 
@@ -215 +212 @@
     //Go until end or a non-digits character
     for (; m_nextPos < m_data.length(); ++m_nextPos) {
-        QChar aChar = m_data[m_nextPos];
-        if (aChar.unicode() >= 0xff) break;
-
-        if (aChar.unicode() < '0' || aChar.unicode() > '9') {
-            if (aChar.unicode() == '.' && !seenDot)
+        UChar aChar = m_data[m_nextPos];
+        if (aChar >= 0xff) break;
+
+        if (aChar < '0' || aChar > '9') {
+            if (aChar == '.' && !seenDot)
                 seenDot = true;
             else
@@ -337 +334 @@
 
     skipWS();
-    //If we're in an operator context, check for any operator names
+    // If we're in an operator context, check for any operator names
     if (isOperatorContext()) {
         if (t1.value == "and") //### hash?
@@ -349 +346 @@
     }
 
-    //See whether we are at a :
+    // See whether we are at a :
     if (peekCurHelper() == ':') {
         m_nextPos++;
-        //Any chance it's an axis name?
+        // Any chance it's an axis name?
         if (peekCurHelper() == ':') {
             m_nextPos++;
@@ -360 +357 @@
             if (isAxisName(t1.value, axisType))
                 return Token(AXISNAME, axisType);
-            //Ugh, :: is only valid in axis names -> error
+            // Ugh, :: is only valid in axis names -> error
             return Token(ERROR);
         }
 
-        //Seems like this is a fully qualified qname, or perhaps the * modified one from NameTest
+        // Seems like this is a fully qualified qname, or perhaps the * modified one from NameTest
         skipWS();
         if (peekCurHelper() == '*') {
@@ -371 +368 @@
         }
         
-        //Make a full qname..
+        // Make a full qname..
         Token t2 = lexNCName();
-        if (t2.type == ERROR) return t2;
-        
-        t1.value = t1.value + ':' + t2.value;
+        if (t2.type == ERROR)
+            return t2;
+        
+        t1.value = t1.value + ":" + t2.value;
     }
 
@@ -433 +431 @@
 }
 
-Expression* Parser::parseStatement(const String& statement, ExceptionCode& code)
+Expression* Parser::parseStatement(const String& statement, ExceptionCode& ec)
 {
     reset(statement);
@@ -449 +447 @@
         
         if (m_gotNamespaceError)
-            code = NAMESPACE_ERR;
+            ec = NAMESPACE_ERR;
         else
-            code = INVALID_EXPRESSION_ERR;
+            ec = INVALID_EXPRESSION_ERR;
         return 0;
     } else {
@@ -550 +548 @@
 
 #endif // XPATH_SUPPORT
-

trunk/WebCore/xpath/impl/XPathParser.h

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #ifndef XPathParser_H
 #define XPathParser_H
@@ -43 +44 @@
 namespace XPath {
 
-struct Token
-{
+struct Token {
     int     type;
     String value;
@@ -50 +50 @@
     
     Token(int t): type(t), intValue(0) {}
-    Token(int t, String v): type(t), value(v) {}
+    Token(int t, const String& v): type(t), value(v) {}
     Token(int t, int v): type(t), intValue(v) {}
 };
@@ -72 +72 @@
     };
     
-    XMLCat charCat(QChar aChar);
+    XMLCat charCat(UChar);
     
-    bool isAxisName(String name, Step::AxisType &type);
-    bool isNodeTypeName(String name);
+    bool isAxisName(const String& name, Step::AxisType &type);
+    bool isNodeTypeName(const String& name);
     bool isOperatorContext();
     
@@ -98 +98 @@
     HashSet<Vector<Expression*>*> m_expressionVectors;
     HashSet<String*> m_strings;
+
 public:
     Parser();

trunk/WebCore/xpath/impl/XPathPath.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
 #if XPATH_SUPPORT
 
-#include "Logging.h"
-
 #include "XPathPath.h"
 
 #include "Document.h"
+#include "Logging.h"
 #include "Node.h"
+#include "XPathValue.h"
 
 namespace WebCore {
@@ -39 +40 @@
         
 Filter::Filter(Expression* expr, const Vector<Predicate*>& predicates)
-    : m_expr(expr),
-    m_predicates(predicates)
+    : m_expr(expr), m_predicates(predicates)
 {
 }

trunk/WebCore/xpath/impl/XPathPredicate.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
@@ -29 +30 @@
 
 #include "XPathPredicate.h"
+
+#include "Logging.h"
+#include "Node.h"
 #include "XPathFunctions.h"
-#include "Logging.h"
-
-#include "Node.h"
-
+#include "XPathValue.h"
 #include <math.h>
 

trunk/WebCore/xpath/impl/XPathValue.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
@@ -29 +30 @@
 
 #include "XPathValue.h"
+
+#include "DeprecatedString.h"
 #include "Logging.h"
 
@@ -42 +45 @@
 
 Value::Value()
+    : m_type(Boolean), m_bool(false)
 {
 }
@@ -48 +52 @@
     : m_type(NodeVector_)
 {
-    m_nodevector.append(value);
+    m_nodeVector.append(value);
 }
 
 Value::Value(const NodeVector& value)
-    : m_type(NodeVector_)
-    , m_nodevector(value)
+    : m_type(NodeVector_), m_nodeVector(value)
 {
 }
 
 Value::Value(bool value)
-    : m_type(Boolean),
-    m_bool(value)
+    : m_type(Boolean), m_bool(value)
+{
+}
+
+Value::Value(unsigned value)
+    : m_type(Number), m_number(value)
+{
+}
+
+Value::Value(unsigned long value)
+    : m_type(Number), m_number(value)
 {
 }
 
 Value::Value(double value)
-    : m_type(Number),
-    m_number(value)
+    : m_type(Number), m_number(value)
 {
 }
 
 Value::Value(const String& value)
-    : m_type(String_),
-    m_string(value)
+    : m_type(String_), m_string(value)
 {
-}
-
-Value::Type Value::type() const
-{
-    return m_type;
-}
-
-bool Value::isNodeVector() const
-{
-    return m_type == NodeVector_;
-}
-
-bool Value::isBoolean() const
-{
-    return m_type == Boolean;
-}
-
-bool Value::isNumber() const
-{
-    return m_type == Number;
-}
-
-bool Value::isString() const
-{
-    return m_type == String_;
-}
-
-NodeVector& Value::toNodeVector()
-{
-    if (m_type != NodeVector_) {
-        LOG(XPath, "Cannot convert anything to a nodevector.");
-    }
-    return m_nodevector;
 }
 
 const NodeVector &Value::toNodeVector() const
 {
-    if (m_type != NodeVector_) {
-        LOG(XPath, "Cannot convert anything to a nodevector.");
-    }
-    
-    return m_nodevector;    
+    if (m_type != NodeVector_)
+        LOG(XPath, "Cannot convert anything to a nodevector.");    
+    return m_nodeVector;    
 }    
 
@@ -121 +96 @@
     switch (m_type) {
         case NodeVector_:
-            return !m_nodevector.isEmpty();
+            return !m_nodeVector.isEmpty();
         case Boolean:
             return m_bool;
@@ -141 +116 @@
         case String_: {
             bool canConvert;
-            DeprecatedString s = m_string.deprecatedString().simplifyWhiteSpace();
-            
-            double value = s.toDouble(&canConvert);
+            double value = m_string.deprecatedString().simplifyWhiteSpace().toDouble(&canConvert);
             if (canConvert)
                 return value;
-
             return NAN;
         }
@@ -159 +131 @@
     switch (m_type) {
         case NodeVector_:
-            if (m_nodevector.isEmpty()) 
+            if (m_nodeVector.isEmpty()) 
                 return "";
-
-            return stringValue(m_nodevector[0].get());
+            return stringValue(m_nodeVector[0].get());
         case String_:
             return m_string;
@@ -168 +139 @@
             if (isnan(m_number))
                 return "NaN";
-            else if (m_number == 0)
+            if (m_number == 0)
                 return "0";
-            else if (isinf(m_number)) {
-                if (signbit(m_number) == 0)
-                    return "Infinity";
-                else
-                    return "-Infinity";
-            }
-            return DeprecatedString::number(m_number);
+            if (isinf(m_number))
+                return signbit(m_number) ? "-Infinity" : "Infinity";
+            return String::number(m_number);
         case Boolean:
             return m_bool ? "true" : "false";
     }
-    
     return String();
 }
-
 
 }

trunk/WebCore/xpath/impl/XPathValue.h

@@ -34 +34 @@
 namespace XPath {
     
-class Value
-{
+class Value {
 public:
-    enum Type {
-        NodeVector_, Boolean, Number, String_
-    };
+    enum Type { NodeVector_, Boolean, Number, String_ };
     
     Value();
-    Value(Node* value);
-    Value(const NodeVector& value);
-    Value(bool value);
-    Value(double value);
-    Value(const String& value);
+    Value(Node*);
+    Value(const NodeVector&);
+    Value(bool);
+    Value(unsigned);
+    Value(unsigned long);
+    Value(double);
+    Value(const String&);
     
-    Type type() const;
-    bool isNodeVector() const;
-    bool isBoolean() const;
-    bool isNumber() const;
-    bool isString() const;
-    
-    NodeVector& toNodeVector();
-    const NodeVector& toNodeVector() const;
-    
+    Type type() const { return m_type; }
+
+    bool isNodeVector() const { return m_type == NodeVector_; }
+    bool isBoolean() const { return m_type == Boolean; }
+    bool isNumber() const { return m_type == Number; }
+    bool isString() const { return m_type == String_; }
+
+    const NodeVector& toNodeVector() const;    
     bool toBoolean() const;
     double toNumber() const;
@@ -63 +61 @@
 private:
     Type m_type;
-    NodeVector m_nodevector;
+    NodeVector m_nodeVector;
     bool m_bool;
     double m_number;

trunk/WebCore/xpath/impl/XPathVariableReference.cpp

@@ -24 +24 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 
@@ -31 +32 @@
 
 #include "PlatformString.h"
+#include "XPathValue.h"
 
 namespace WebCore {