Reviewed by Tim Hatcher.
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 5 May 2006 22:50:28 +0000 (22:50 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 5 May 2006 22:50:28 +0000 (22:50 +0000)
        - remove a few of the stranger features of QChar on the road to
          eventually replacing it with an integer type (probably ICU's UChar)

        * platform/DeprecatedString.h: Remove SpecialCharacter, byteOrderMark, null,
        cell, row, isNull, mirrored, mirroredChar, operator char, >, >=, <, and <=
        from QChar. Also removed the many unneeded friend declarations. Remove findArg
        and arg from DeprecatedString.

        * dom/Document.cpp: (WebCore::Document::parseQualifiedName): Cast the type of the
        buffer before invoking the U16_NEXT function. Turns out this was converting each
        QChar to a char and back to a UChar, which means it caused a bug with characters
        that are U+0100 or greater.

        * css/csshelper.cpp: (WebCore::parseURL):
        * html/HTMLInputElement.cpp: (WebCore::HTMLInputElement::constrainValue):
        * platform/StringImpl.cpp: (WebCore::StringImpl::toCoordsArray):
        * xml/xmlhttprequest.cpp: (WebCore::getCharset):
        Add some calls to unicode() since we don't have comparison operators any more.

        * dom/StyledElement.cpp:
        (WebCore::toHex): Rewrote to just take a UChar parameter.
        (WebCore::StyledElement::addCSSColor): Call toHex on the character code.

        * bridge/mac/WebCoreFrameBridge.mm:
        (-[WebCoreFrameBridge smartInsertForString:replacingRange:beforeString:afterString:]):
        * editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::doApply):
        * editing/TextIterator.cpp: (WebCore::TextIterator::handleTextBox):
        * platform/SegmentedString.h:
        (WebCore::SegmentedString::push):
        (WebCore::SegmentedString::advance):
        (WebCore::SegmentedString::escaped):
        * platform/SegmentedString.cpp:
        (WebCore::SegmentedString::length):
        (WebCore::SegmentedString::append):
        (WebCore::SegmentedString::prepend):
        (WebCore::SegmentedString::toString):
        Changed calls to isNull() to instead just use unicode() and check for 0.

        * html/HTMLTokenizer.cpp:
        (WebCore::HTMLTokenizer::parseEntity): Change callers that used cell and row to
        just use unicode() instead.
        (WebCore::HTMLTokenizer::parseTag): Ditto.

        * loader/Decoder.cpp: (Decoder::decode): Changed code that did a type cast to
        unsigned char to instead call unicode().

        * platform/DeprecatedString.cpp:
        (KWQStringData::makeAscii): Call latin1() instead of relying on the conversion operator.
        (DeprecatedString::DeprecatedString): Call unicode() instead of relying on the conversion
        operator (the character has been tested and is known to be ASCII).
        (DeprecatedString::at): Use 0 instead of QChar::null.
        (DeprecatedString::compare): Use unicode() so we can do comparison since we don't have
        comparison operators any more.
        (DeprecatedString::find): Call unicode() instead of relying on the conversion
        operator (the character has been tested and is known to be ASCII).
        (DeprecatedString::findRev): Ditto.
        (DeprecatedString::copyLatin1): Call latin1() instead of relying on the conversion operator.
        (DeprecatedString::lower): Call unicode() instead of relying on the conversion
        operator (the character has been tested and is known to be ASCII).
        (DeprecatedString::insert): Ditto.
        (DeprecatedString::replace): Ditto.
        (DeprecatedString::fill): Ditto.
        (DeprecatedString::append): Ditto.

        * html/html_inlineimpl.cpp: (WebCore::HTMLAnchorElement::defaultEventHandler):
        Eliminate the one use of DeprecatedString::arg.

        - other cleanup

        * kwq/KWQCString.cpp: Remove unneeded "using" directive.

        * html/HTMLElementFactory.cpp:
        (WebCore::htmlConstructor):
        (WebCore::headConstructor):
        (WebCore::bodyConstructor):
        (WebCore::baseConstructor):
        (WebCore::linkConstructor):
        (WebCore::metaConstructor):
        (WebCore::styleConstructor):
        (WebCore::titleConstructor):
        (WebCore::frameConstructor):
        (WebCore::framesetConstructor):
        (WebCore::iframeConstructor):
        (WebCore::formConstructor):
        (WebCore::buttonConstructor):
        (WebCore::inputConstructor):
        (WebCore::isindexConstructor):
        (WebCore::fieldsetConstructor):
        (WebCore::labelConstructor):
        (WebCore::legendConstructor):
        (WebCore::optgroupConstructor):
        (WebCore::optionConstructor):
        (WebCore::selectConstructor):
        (WebCore::textareaConstructor):
        (WebCore::dlConstructor):
        (WebCore::ulConstructor):
        (WebCore::olConstructor):
        (WebCore::dirConstructor):
        (WebCore::menuConstructor):
        (WebCore::liConstructor):
        (WebCore::blockquoteConstructor):
        (WebCore::divConstructor):
        (WebCore::headingConstructor):
        (WebCore::hrConstructor):
        (WebCore::paragraphConstructor):
        (WebCore::preConstructor):
        (WebCore::basefontConstructor):
        (WebCore::fontConstructor):
        (WebCore::modConstructor):
        (WebCore::anchorConstructor):
        (WebCore::imageConstructor):
        (WebCore::mapConstructor):
        (WebCore::areaConstructor):
        (WebCore::canvasConstructor):
        (WebCore::appletConstructor):
        (WebCore::embedConstructor):
        (WebCore::objectConstructor):
        (WebCore::paramConstructor):
        (WebCore::scriptConstructor):
        (WebCore::tableConstructor):
        (WebCore::tableCaptionConstructor):
        (WebCore::tableColConstructor):
        (WebCore::tableRowConstructor):
        (WebCore::tableCellConstructor):
        (WebCore::tableSectionConstructor):
        (WebCore::brConstructor):
        (WebCore::quoteConstructor):
        (WebCore::marqueeConstructor):
        Mark functions static, remove unused parameters, change from docPtr to doc.

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

19 files changed:
WebCore/ChangeLog
WebCore/bridge/mac/WebCoreFrameBridge.mm
WebCore/css/csshelper.cpp
WebCore/dom/Document.cpp
WebCore/dom/StyledElement.cpp
WebCore/editing/ReplaceSelectionCommand.cpp
WebCore/editing/TextIterator.cpp
WebCore/html/HTMLElementFactory.cpp
WebCore/html/HTMLInputElement.cpp
WebCore/html/HTMLTokenizer.cpp
WebCore/html/html_inlineimpl.cpp
WebCore/kwq/KWQCString.cpp
WebCore/loader/Decoder.cpp
WebCore/platform/DeprecatedString.cpp
WebCore/platform/DeprecatedString.h
WebCore/platform/SegmentedString.cpp
WebCore/platform/SegmentedString.h
WebCore/platform/StringImpl.cpp
WebCore/xml/xmlhttprequest.cpp

index 6b62324..9ffb27c 100644 (file)
@@ -1,3 +1,137 @@
+2006-05-05  Darin Adler  <darin@apple.com>
+
+        Reviewed by Tim Hatcher.
+
+        - remove a few of the stranger features of QChar on the road to
+          eventually replacing it with an integer type (probably ICU's UChar)
+
+        * platform/DeprecatedString.h: Remove SpecialCharacter, byteOrderMark, null,
+        cell, row, isNull, mirrored, mirroredChar, operator char, >, >=, <, and <=
+        from QChar. Also removed the many unneeded friend declarations. Remove findArg
+        and arg from DeprecatedString.
+
+        * dom/Document.cpp: (WebCore::Document::parseQualifiedName): Cast the type of the
+        buffer before invoking the U16_NEXT function. Turns out this was converting each
+        QChar to a char and back to a UChar, which means it caused a bug with characters
+        that are U+0100 or greater.
+
+        * css/csshelper.cpp: (WebCore::parseURL):
+        * html/HTMLInputElement.cpp: (WebCore::HTMLInputElement::constrainValue):
+        * platform/StringImpl.cpp: (WebCore::StringImpl::toCoordsArray):
+        * xml/xmlhttprequest.cpp: (WebCore::getCharset):
+        Add some calls to unicode() since we don't have comparison operators any more.
+
+        * dom/StyledElement.cpp:
+        (WebCore::toHex): Rewrote to just take a UChar parameter.
+        (WebCore::StyledElement::addCSSColor): Call toHex on the character code.
+
+        * bridge/mac/WebCoreFrameBridge.mm:
+        (-[WebCoreFrameBridge smartInsertForString:replacingRange:beforeString:afterString:]):
+        * editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::doApply):
+        * editing/TextIterator.cpp: (WebCore::TextIterator::handleTextBox):
+        * platform/SegmentedString.h:
+        (WebCore::SegmentedString::push):
+        (WebCore::SegmentedString::advance):
+        (WebCore::SegmentedString::escaped):
+        * platform/SegmentedString.cpp:
+        (WebCore::SegmentedString::length):
+        (WebCore::SegmentedString::append):
+        (WebCore::SegmentedString::prepend):
+        (WebCore::SegmentedString::toString):
+        Changed calls to isNull() to instead just use unicode() and check for 0.
+
+        * html/HTMLTokenizer.cpp:
+        (WebCore::HTMLTokenizer::parseEntity): Change callers that used cell and row to
+        just use unicode() instead.
+        (WebCore::HTMLTokenizer::parseTag): Ditto.
+
+        * loader/Decoder.cpp: (Decoder::decode): Changed code that did a type cast to
+        unsigned char to instead call unicode().
+
+        * platform/DeprecatedString.cpp:
+        (KWQStringData::makeAscii): Call latin1() instead of relying on the conversion operator.
+        (DeprecatedString::DeprecatedString): Call unicode() instead of relying on the conversion
+        operator (the character has been tested and is known to be ASCII).
+        (DeprecatedString::at): Use 0 instead of QChar::null.
+        (DeprecatedString::compare): Use unicode() so we can do comparison since we don't have
+        comparison operators any more.
+        (DeprecatedString::find): Call unicode() instead of relying on the conversion
+        operator (the character has been tested and is known to be ASCII).
+        (DeprecatedString::findRev): Ditto.
+        (DeprecatedString::copyLatin1): Call latin1() instead of relying on the conversion operator.
+        (DeprecatedString::lower): Call unicode() instead of relying on the conversion
+        operator (the character has been tested and is known to be ASCII).
+        (DeprecatedString::insert): Ditto.
+        (DeprecatedString::replace): Ditto.
+        (DeprecatedString::fill): Ditto.
+        (DeprecatedString::append): Ditto.
+
+        * html/html_inlineimpl.cpp: (WebCore::HTMLAnchorElement::defaultEventHandler):
+        Eliminate the one use of DeprecatedString::arg.
+
+        - other cleanup
+
+        * kwq/KWQCString.cpp: Remove unneeded "using" directive.
+
+        * html/HTMLElementFactory.cpp:
+        (WebCore::htmlConstructor):
+        (WebCore::headConstructor):
+        (WebCore::bodyConstructor):
+        (WebCore::baseConstructor):
+        (WebCore::linkConstructor):
+        (WebCore::metaConstructor):
+        (WebCore::styleConstructor):
+        (WebCore::titleConstructor):
+        (WebCore::frameConstructor):
+        (WebCore::framesetConstructor):
+        (WebCore::iframeConstructor):
+        (WebCore::formConstructor):
+        (WebCore::buttonConstructor):
+        (WebCore::inputConstructor):
+        (WebCore::isindexConstructor):
+        (WebCore::fieldsetConstructor):
+        (WebCore::labelConstructor):
+        (WebCore::legendConstructor):
+        (WebCore::optgroupConstructor):
+        (WebCore::optionConstructor):
+        (WebCore::selectConstructor):
+        (WebCore::textareaConstructor):
+        (WebCore::dlConstructor):
+        (WebCore::ulConstructor):
+        (WebCore::olConstructor):
+        (WebCore::dirConstructor):
+        (WebCore::menuConstructor):
+        (WebCore::liConstructor):
+        (WebCore::blockquoteConstructor):
+        (WebCore::divConstructor):
+        (WebCore::headingConstructor):
+        (WebCore::hrConstructor):
+        (WebCore::paragraphConstructor):
+        (WebCore::preConstructor):
+        (WebCore::basefontConstructor):
+        (WebCore::fontConstructor):
+        (WebCore::modConstructor):
+        (WebCore::anchorConstructor):
+        (WebCore::imageConstructor):
+        (WebCore::mapConstructor):
+        (WebCore::areaConstructor):
+        (WebCore::canvasConstructor):
+        (WebCore::appletConstructor):
+        (WebCore::embedConstructor):
+        (WebCore::objectConstructor):
+        (WebCore::paramConstructor):
+        (WebCore::scriptConstructor):
+        (WebCore::tableConstructor):
+        (WebCore::tableCaptionConstructor):
+        (WebCore::tableColConstructor):
+        (WebCore::tableRowConstructor):
+        (WebCore::tableCellConstructor):
+        (WebCore::tableSectionConstructor):
+        (WebCore::brConstructor):
+        (WebCore::quoteConstructor):
+        (WebCore::marqueeConstructor):
+        Mark functions static, remove unused parameters, change from docPtr to doc.
+
 2006-05-05  Alexey Proskuryakov  <ap@nypop.com>
 
         Reviewed by Maciej.
index 2b0ae11..9f8d255 100644 (file)
@@ -1818,17 +1818,15 @@ static HTMLFormElement *formElementFromDOMElement(DOMElement *element)
     bool addLeadingSpace = startPos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isStartOfParagraph(startVisiblePos);
     if (addLeadingSpace) {
         QChar previousChar = startVisiblePos.previous().characterAfter();
-        if (!previousChar.isNull()) {
+        if (previousChar.unicode())
             addLeadingSpace = !m_frame->isCharacterSmartReplaceExempt(previousChar, true);
-        }
     }
     
     bool addTrailingSpace = endPos.trailingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isEndOfParagraph(endVisiblePos);
     if (addTrailingSpace) {
         QChar thisChar = endVisiblePos.characterAfter();
-        if (!thisChar.isNull()) {
+        if (thisChar.unicode())
             addTrailingSpace = !m_frame->isCharacterSmartReplaceExempt(thisChar, false);
-        }
     }
     
     // inspect source
index 2ab10d1..7638108 100644 (file)
@@ -38,11 +38,11 @@ String parseURL(const String& url)
     int o = 0;
     int l = i->length();
 
-    while (o < l && (*i)[o] <= ' ') {
+    while (o < l && (*i)[o].unicode() <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1] <= ' ')
+    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
         --l;
 
     if (l >= 5
@@ -55,11 +55,11 @@ String parseURL(const String& url)
         l -= 5;
     }
 
-    while (o < l && (*i)[o] <= ' ') {
+    while (o < l && (*i)[o].unicode() <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1] <= ' ')
+    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
         --l;
 
     if (l >= 2 && (*i)[o] == (*i)[o+l-1] && ((*i)[o] == '\'' || (*i)[o] == '\"')) {
@@ -67,11 +67,11 @@ String parseURL(const String& url)
         l -= 2;
     }
 
-    while (o < l && (*i)[o] <= ' ') {
+    while (o < l && (*i)[o].unicode() <= ' ') {
         ++o;
         --l;
     }
-    while (l > 0 && (*i)[o+l-1] <= ' ')
+    while (l > 0 && (*i)[o+l-1].unicode() <= ' ')
         --l;
 
     Vector<unsigned short, 2048> buffer(l);
index 982a4a1..ceb563a 100644 (file)
@@ -2419,7 +2419,7 @@ bool Document::parseQualifiedName(const String &qualifiedName, String &prefix, S
     bool sawColon = false;
     int colonPos = 0;
 
-    const QChar *s = qualifiedName.unicode();
+    const UChar* s = reinterpret_cast<const UChar*>(qualifiedName.unicode());
     for (unsigned i = 0; i < length;) {
         UChar32 c;
         U16_NEXT(s, i, length, c)
index 1a9a08c..57e9d32 100644 (file)
@@ -253,20 +253,11 @@ const AtomicStringList* StyledElement::getClassList() const
     return namedAttrMap ? mappedAttributes()->getClassList() : 0;
 }
 
-static inline bool isHexDigit( const QChar &c ) {
-    return ( c >= '0' && c <= '9' ) ||
-           ( c >= 'a' && c <= 'f' ) ||
-           ( c >= 'A' && c <= 'F' );
-}
-
-static inline int toHex( const QChar &c ) {
-    return ( (c >= '0' && c <= '9')
-             ? (c.unicode() - '0')
-             : ( ( c >= 'a' && c <= 'f' )
-                 ? (c.unicode() - 'a' + 10)
-                 : ( ( c >= 'A' && c <= 'F' )
-                     ? (c.unicode() - 'A' + 10)
-                     : -1 ) ) );
+static inline int toHex(UChar c) {
+    return ((c >= '0' && c <= '9') ? (c - '0')
+        : ((c >= 'a' && c <= 'f') ? (c - 'a' + 10)
+        : (( c >= 'A' && c <= 'F') ? (c - 'A' + 10)
+        : -1)));
 }
 
 void StyledElement::addCSSProperty(MappedAttribute* attr, int id, const String &value)
@@ -367,7 +358,7 @@ void StyledElement::addCSSColor(MappedAttribute* attr, int id, const String &c)
                 // search forward for digits in the string
                 int numDigits = 0;
                 while (pos < (int)color.length() && numDigits < basicLength) {
-                    int hex = toHex(color[pos]);
+                    int hex = toHex(color[pos].unicode());
                     colors[component] = (colors[component] << 4);
                     if (hex > 0) {
                         colors[component] += hex;
index d14644c..9a05ed7 100644 (file)
@@ -620,16 +620,14 @@ void ReplaceSelectionCommand::doApply()
         addLeadingSpace = startPos.leadingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isStartOfParagraph(visiblePos);
         if (addLeadingSpace) {
             QChar previousChar = visiblePos.previous().characterAfter();
-            if (!previousChar.isNull()) {
+            if (previousChar.unicode())
                 addLeadingSpace = !frame->isCharacterSmartReplaceExempt(previousChar, true);
-            }
         }
         addTrailingSpace = startPos.trailingWhitespacePosition(VP_DEFAULT_AFFINITY, true).isNull() && !isEndOfParagraph(visiblePos);
         if (addTrailingSpace) {
             QChar thisChar = visiblePos.characterAfter();
-            if (!thisChar.isNull()) {
+            if (thisChar.unicode())
                 addTrailingSpace = !frame->isCharacterSmartReplaceExempt(thisChar, false);
-            }
         }
     }
     
index 87ee528..fe5b9c5 100644 (file)
@@ -271,7 +271,7 @@ void TextIterator::handleTextBox()
         InlineTextBox *firstTextBox = renderer->containsReversedText() ? m_sortedTextBoxes[0] : renderer->firstTextBox();
         bool needSpace = m_lastTextNodeEndedWithCollapsedSpace
             || (m_textBox == firstTextBox && textBoxStart == runStart && runStart > 0);
-        if (needSpace && !isCollapsibleWhitespace(m_lastCharacter) && !m_lastCharacter.isNull()) {
+        if (needSpace && !isCollapsibleWhitespace(m_lastCharacter) && m_lastCharacter.unicode()) {
             emitCharacter(' ', m_node, 0, runStart, runStart);
             return;
         }
index 9754ec0..e588f75 100644 (file)
@@ -51,288 +51,288 @@ typedef PassRefPtr<HTMLElement> (*ConstructorFunc)(const AtomicString& tagName,
 typedef HashMap<AtomicStringImpl*, ConstructorFunc> FunctionMap;
 static FunctionMap* gFunctionMap;
 
-PassRefPtr<HTMLElement> htmlConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> htmlConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLHtmlElement(docPtr);
+    return new HTMLHtmlElement(doc);
 }
 
-PassRefPtr<HTMLElement> headConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> headConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLHeadElement(docPtr);
+    return new HTMLHeadElement(doc);
 }
 
-PassRefPtr<HTMLElement> bodyConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> bodyConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLBodyElement(docPtr);
+    return new HTMLBodyElement(doc);
 }
 
-PassRefPtr<HTMLElement> baseConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> baseConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLBaseElement(docPtr);
+    return new HTMLBaseElement(doc);
 }
 
-PassRefPtr<HTMLElement> linkConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> linkConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLLinkElement(docPtr);
+    return new HTMLLinkElement(doc);
 }
 
-PassRefPtr<HTMLElement> metaConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> metaConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLMetaElement(docPtr);
+    return new HTMLMetaElement(doc);
 }
 
-PassRefPtr<HTMLElement> styleConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> styleConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLStyleElement(docPtr);
+    return new HTMLStyleElement(doc);
 }
 
-PassRefPtr<HTMLElement> titleConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> titleConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTitleElement(docPtr);
+    return new HTMLTitleElement(doc);
 }
 
-PassRefPtr<HTMLElement> frameConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> frameConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLFrameElement(docPtr);
+    return new HTMLFrameElement(doc);
 }
 
-PassRefPtr<HTMLElement> framesetConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> framesetConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLFrameSetElement(docPtr);
+    return new HTMLFrameSetElement(doc);
 }
 
-PassRefPtr<HTMLElement> iframeConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> iframeConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLIFrameElement(docPtr);
+    return new HTMLIFrameElement(doc);
 }
 
-PassRefPtr<HTMLElement> formConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> formConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLFormElement(docPtr);
+    return new HTMLFormElement(doc);
 }
 
-PassRefPtr<HTMLElement> buttonConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> buttonConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLButtonElement(docPtr, form);
+    return new HTMLButtonElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> inputConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> inputConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLInputElement(docPtr, form);
+    return new HTMLInputElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> isindexConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> isindexConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLIsIndexElement(docPtr, form);
+    return new HTMLIsIndexElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> fieldsetConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> fieldsetConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLFieldSetElement(docPtr, form);
+    return new HTMLFieldSetElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> labelConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> labelConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLLabelElement(docPtr);
+    return new HTMLLabelElement(doc);
 }
 
-PassRefPtr<HTMLElement> legendConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> legendConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLLegendElement(docPtr, form);
+    return new HTMLLegendElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> optgroupConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> optgroupConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLOptGroupElement(docPtr, form);
+    return new HTMLOptGroupElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> optionConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> optionConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLOptionElement(docPtr, form);
+    return new HTMLOptionElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> selectConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> selectConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLSelectElement(docPtr, form);
+    return new HTMLSelectElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> textareaConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> textareaConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLTextAreaElement(docPtr, form);
+    return new HTMLTextAreaElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> dlConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> dlConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLDListElement(docPtr);
+    return new HTMLDListElement(doc);
 }
 
-PassRefPtr<HTMLElement> ulConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> ulConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLUListElement(docPtr);
+    return new HTMLUListElement(doc);
 }
 
-PassRefPtr<HTMLElement> olConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> olConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLOListElement(docPtr);
+    return new HTMLOListElement(doc);
 }
 
-PassRefPtr<HTMLElement> dirConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> dirConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLDirectoryElement(docPtr);
+    return new HTMLDirectoryElement(doc);
 }
 
-PassRefPtr<HTMLElement> menuConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> menuConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLMenuElement(docPtr);
+    return new HTMLMenuElement(doc);
 }
 
-PassRefPtr<HTMLElement> liConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> liConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLLIElement(docPtr);
+    return new HTMLLIElement(doc);
 }
 
-PassRefPtr<HTMLElement> blockquoteConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> blockquoteConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLBlockquoteElement(docPtr);
+    return new HTMLBlockquoteElement(doc);
 }
 
-PassRefPtr<HTMLElement> divConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> divConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLDivElement(docPtr);
+    return new HTMLDivElement(doc);
 }
 
-PassRefPtr<HTMLElement> headingConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> headingConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLHeadingElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr);
+    return new HTMLHeadingElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc);
 }
 
-PassRefPtr<HTMLElement> hrConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> hrConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLHRElement(docPtr);
+    return new HTMLHRElement(doc);
 }
 
-PassRefPtr<HTMLElement> paragraphConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> paragraphConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLParagraphElement(docPtr);
+    return new HTMLParagraphElement(doc);
 }
 
-PassRefPtr<HTMLElement> preConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> preConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLPreElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr);
+    return new HTMLPreElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc);
 }
 
-PassRefPtr<HTMLElement> basefontConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> basefontConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLBaseFontElement(docPtr);
+    return new HTMLBaseFontElement(doc);
 }
 
-PassRefPtr<HTMLElement> fontConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> fontConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLFontElement(docPtr);
+    return new HTMLFontElement(doc);
 }
 
-PassRefPtr<HTMLElement> modConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> modConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLModElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr);
+    return new HTMLModElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc);
 }
 
-PassRefPtr<HTMLElement> anchorConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> anchorConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLAnchorElement(docPtr);
+    return new HTMLAnchorElement(doc);
 }
 
-PassRefPtr<HTMLElement> imageConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> imageConstructor(const AtomicString&, Document* doc, HTMLFormElement* form, bool)
 {
-    return new HTMLImageElement(docPtr, form);
+    return new HTMLImageElement(doc, form);
 }
 
-PassRefPtr<HTMLElement> mapConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> mapConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLMapElement(docPtr);
+    return new HTMLMapElement(doc);
 }
 
-PassRefPtr<HTMLElement> areaConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> areaConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLAreaElement(docPtr);
+    return new HTMLAreaElement(doc);
 }
 
-PassRefPtr<HTMLElement> canvasConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> canvasConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLCanvasElement(docPtr);
+    return new HTMLCanvasElement(doc);
 }
 
-PassRefPtr<HTMLElement> appletConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> appletConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLAppletElement(docPtr);
+    return new HTMLAppletElement(doc);
 }
 
-PassRefPtr<HTMLElement> embedConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> embedConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLEmbedElement(docPtr);
+    return new HTMLEmbedElement(doc);
 }
 
-PassRefPtr<HTMLElement> objectConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> objectConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool createdByParser)
 {
-    RefPtr<HTMLObjectElement> object = new HTMLObjectElement(docPtr);
+    RefPtr<HTMLObjectElement> object = new HTMLObjectElement(doc);
     object->setComplete(!createdByParser);
     return object.release();
 }
 
-PassRefPtr<HTMLElement> paramConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> paramConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLParamElement(docPtr);
+    return new HTMLParamElement(doc);
 }
 
-PassRefPtr<HTMLElement> scriptConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> scriptConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool createdByParser)
 {
-    RefPtr<HTMLScriptElement> script = new HTMLScriptElement(docPtr);
+    RefPtr<HTMLScriptElement> script = new HTMLScriptElement(doc);
     script->setCreatedByParser(createdByParser);
     return script.release();
 }
 
-PassRefPtr<HTMLElement> tableConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableElement(docPtr);
+    return new HTMLTableElement(doc);
 }
 
-PassRefPtr<HTMLElement> tableCaptionConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableCaptionConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableCaptionElement(docPtr);
+    return new HTMLTableCaptionElement(doc);
 }
 
-PassRefPtr<HTMLElement> tableColConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableColConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableColElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr);
+    return new HTMLTableColElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc);
 }
 
-PassRefPtr<HTMLElement> tableRowConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableRowConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableRowElement(docPtr);
+    return new HTMLTableRowElement(doc);
 }
 
-PassRefPtr<HTMLElement> tableCellConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableCellConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableCellElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr);
+    return new HTMLTableCellElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc);
 }
 
-PassRefPtr<HTMLElement> tableSectionConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> tableSectionConstructor(const AtomicString& tagName, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLTableSectionElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), docPtr, false);
+    return new HTMLTableSectionElement(QualifiedName(nullAtom, tagName, xhtmlNamespaceURI), doc, false);
 }
 
-PassRefPtr<HTMLElement> brConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> brConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLBRElement(docPtr);
+    return new HTMLBRElement(doc);
 }
 
-PassRefPtr<HTMLElement> quoteConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> quoteConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLQuoteElement(docPtr);
+    return new HTMLQuoteElement(doc);
 }
 
-PassRefPtr<HTMLElement> marqueeConstructor(const AtomicString& tagName, Document* docPtr, HTMLFormElement* form, bool createdByParser)
+static PassRefPtr<HTMLElement> marqueeConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool)
 {
-    return new HTMLMarqueeElement(docPtr);
+    return new HTMLMarqueeElement(doc);
 }
 
 static void addTag(const QualifiedName& tag, ConstructorFunc func)
index f260354..73a1d66 100644 (file)
@@ -1442,7 +1442,7 @@ String HTMLInputElement::constrainValue(const String& proposedValue, int maxLen)
         StringImpl* s = proposedValue.impl();
         int newLen = numCharactersInGraphemeClusters(s, maxLen);
         for (int i = 0; i < newLen; ++i)
-            if ((*s)[i] < ' ') {
+            if ((*s)[i].unicode() < ' ') {
                 newLen = i;
                 break;
             }
index e43445f..a633f9e 100644 (file)
@@ -671,9 +671,9 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
             int ll = min(src.length(), 10-cBufferPos);
             while(ll--) {
                 QChar csrc(src->lower());
-                cc = csrc.cell();
+                cc = csrc.unicode();
 
-                if(csrc.row() || !((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f'))) {
+                if (!((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f'))) {
                     state.setEntityState(SearchSemicolon);
                     break;
                 }
@@ -689,9 +689,9 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
         {
             int ll = min(src.length(), 9-cBufferPos);
             while(ll--) {
-                cc = src->cell();
+                cc = src->unicode();
 
-                if(src->row() || !(cc >= '0' && cc <= '9')) {
+                if (!(cc >= '0' && cc <= '9')) {
                     state.setEntityState(SearchSemicolon);
                     break;
                 }
@@ -709,10 +709,9 @@ HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, QChar *&de
             int ll = min(src.length(), 9-cBufferPos);
             while(ll--) {
                 QChar csrc = *src;
-                cc = csrc.cell();
+                cc = csrc.unicode();
 
-                if(csrc.row() || !((cc >= 'a' && cc <= 'z') ||
-                                   (cc >= '0' && cc <= '9') || (cc >= 'A' && cc <= 'Z'))) {
+                if (!((cc >= 'a' && cc <= 'z') || (cc >= '0' && cc <= '9') || (cc >= 'A' && cc <= 'Z'))) {
                     state.setEntityState(SearchSemicolon);
                     break;
                 }
@@ -821,7 +820,8 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
                           state.setInComment(false);
                           ++src;
                           if (!src.isEmpty())
-                              cBuffer[cBufferPos++] = src->cell();
+                              // cuts off high bits, which is okay
+                              cBuffer[cBufferPos++] = src->unicode();
                         }
                         else
                           state = parseComment(src, state);
@@ -829,8 +829,8 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
                         m_cBufferPos = cBufferPos;
                         return state; // Finished parsing tag!
                     }
-                    // cuts of high part, is okay
-                    cBuffer[cBufferPos++] = src->cell();
+                    // cuts off high bits, which is okay
+                    cBuffer[cBufferPos++] = src->unicode();
                     ++src;
                     break;
                 }
index 045620f..e9c6eaf 100644 (file)
@@ -158,7 +158,10 @@ void HTMLAnchorElement::defaultEventHandler(Event *evt)
                     int absx, absy;
                     r->absolutePosition(absx, absy);
                     int x(e->clientX() - absx), y(e->clientY() - absy);
-                    url += DeprecatedString("?%1,%2").arg( x ).arg( y );
+                    url += "?";
+                    url += DeprecatedString::number(x);
+                    url += ",";
+                    url += DeprecatedString::number(y);
                 }
                 else {
                     evt->setDefaultHandled();
index 4ef1918..e65cbef 100644 (file)
@@ -29,8 +29,6 @@
 #include <kxmlcore/Assertions.h>
 #include <ctype.h>
 
-using std::ostream;
-
 DeprecatedCString::DeprecatedCString()
 {
 }
index 6b7a59c..63e427e 100644 (file)
@@ -366,8 +366,8 @@ DeprecatedString Decoder::decode(const char *data, int len)
             // Handle the case where some of bytes are already in the buffer.
             // The last byte is always guaranteed to not be in the buffer.
             const unsigned char *udata = (const unsigned char *)data;
-            unsigned char c1 = bufferLength >= 1 ? (unsigned char)buffer[0] : *udata++;
-            unsigned char c2 = bufferLength >= 2 ? (unsigned char)buffer[1] : *udata++;
+            unsigned char c1 = bufferLength >= 1 ? buffer[0].unicode() : *udata++;
+            unsigned char c2 = bufferLength >= 2 ? buffer[1].unicode() : *udata++;
             ASSERT(bufferLength < 3);
             unsigned char c3 = *udata;
 
index 1451c0d..5021eba 100644 (file)
@@ -456,9 +456,9 @@ char *KWQStringData::makeAscii()
         }
 
         unsigned i = _length;
-        char *cp = _ascii;
-        while ( i-- )
-            *cp++ = *str++;
+        charcp = _ascii;
+        while (i--)
+            *cp++ = (*str++).latin1();
         *cp = 0;
         
         _isAsciiValid = 1;
@@ -633,7 +633,7 @@ DeprecatedString::DeprecatedString(QChar qc)
 
     // Copy the QChar.
     if (IS_ASCII_QCHAR(qc)) {
-        char c = (char)qc
+        char c = qc.unicode()
         *dataHandle = &internalData;
         internalData.initialize( &c, 1 );
     }
@@ -737,7 +737,7 @@ QChar DeprecatedString::at(unsigned i) const
     KWQStringData *thisData = *dataHandle;
     
     if (i >= thisData->_length)
-        return QChar::null;
+        return 0;
         
     if (thisData->_isAsciiValid) {
         return thisData->_ascii[i];
@@ -768,9 +768,9 @@ int DeprecatedString::compare(const char *chs) const
         if (!c2)
             return 1;
         QChar c1 = s[i];
-        if (c1 < c2)
+        if (c1.unicode() < c2)
             return -1;
-        if (c1 > c2)
+        if (c1.unicode() > c2)
             return 1;
     }
     return chs[len] ? -1 : 0;
@@ -880,10 +880,9 @@ bool DeprecatedString::isNull() const
 int DeprecatedString::find(QChar qc, int index) const
 {
     if (dataHandle[0]->_isAsciiValid) {
-        if (!IS_ASCII_QCHAR(qc)) {
+        if (!IS_ASCII_QCHAR(qc))
             return -1;
-        }
-        return find((char)qc, index);
+        return find(qc.unicode(), index);
     }
     return find(DeprecatedString(qc), index, true);
 }
@@ -1093,8 +1092,8 @@ int DeprecatedString::findRev( const DeprecatedString& str, int index, bool cs )
     int i;
     if ( cs ) {
         for ( i = 0; i < lstr; i++ ) {
-            hthis += uthis[index + i].cell();
-            hstr += ustr[i].cell();
+            hthis += uthis[index + i].unicode();
+            hstr += ustr[i].unicode();
         }
         i = index;
         while ( true ) {
@@ -1103,13 +1102,13 @@ int DeprecatedString::findRev( const DeprecatedString& str, int index, bool cs )
             if ( i == 0 )
                 return -1;
             i--;
-            hthis -= uthis[i + lstr].cell();
-            hthis += uthis[i].cell();
+            hthis -= uthis[i + lstr].unicode();
+            hthis += uthis[i].unicode();
         }
     } else {
         for ( i = 0; i < lstr; i++ ) {
-            hthis += uthis[index + i].lower().cell();
-            hstr += ustr[i].lower().cell();
+            hthis += uthis[index + i].lower().unicode();
+            hstr += ustr[i].lower().unicode();
         }
         i = index;
         while ( true ) {
@@ -1118,8 +1117,8 @@ int DeprecatedString::findRev( const DeprecatedString& str, int index, bool cs )
             if ( i == 0 )
                 return -1;
             i--;
-            hthis -= uthis[i + lstr].lower().cell();
-            hthis += uthis[i].lower().cell();
+            hthis -= uthis[i + lstr].lower().unicode();
+            hthis += uthis[i].lower().unicode();
         }
     }
 
@@ -1330,9 +1329,9 @@ void DeprecatedString::copyLatin1(char *buffer, unsigned position, unsigned maxL
     }
 
     ASSERT(data->_isUnicodeValid);
-    const QChar *uc = data->_unicode + position;
+    const QCharuc = data->_unicode + position;
     while (length--)
-        *buffer++ = *uc++;
+        *buffer++ = (*uc++).latin1();
 }
 
 short DeprecatedString::toShort(bool *ok, int base) const
@@ -1472,103 +1471,19 @@ double DeprecatedString::toDouble(bool *ok) const
     return val;
 }
 
-bool DeprecatedString::findArg(int& pos, int& len) const
-{
-    char lowest=0;
-    for (unsigned i = 0; i< dataHandle[0]->_length; i++) {
-        if ( at(i) == '%' && i + 1 < dataHandle[0]->_length ) {
-            char dig = at(i+1);
-            if ( dig >= '0' && dig <= '9' ) {
-                if ( !lowest || dig < lowest ) {
-                    lowest = dig;
-                    pos = i;
-                    len = 2;
-                }
-            }
-        }
-    }
-    return lowest != 0;
-}
-
-DeprecatedString DeprecatedString::arg(const DeprecatedString &a, int fieldwidth) const
-{
-    int pos, len;
-    DeprecatedString r = *this;
-
-    if ( !findArg( pos, len ) ) {
-        // Make sure the text at least appears SOMEWHERE
-        r += ' ';
-        pos = r.dataHandle[0]->_length;
-        len = 0;
-    }
-
-    r.replace( pos, len, a );
-    if ( fieldwidth < 0 ) {
-        DeprecatedString s;
-        while ( (unsigned)-fieldwidth > a.dataHandle[0]->_length ) {
-            s += ' ';
-            fieldwidth++;
-        }
-        r.insert( pos + a.dataHandle[0]->_length, s );
-    } else if ( fieldwidth ) {
-        DeprecatedString s;
-        while ( (unsigned)fieldwidth > a.dataHandle[0]->_length ) {
-            s += ' ';
-            fieldwidth--;
-        }
-        r.insert( pos, s );
-    }
-
-    return r;
-}
-
-DeprecatedString DeprecatedString::arg(short replacement, int width) const
-{
-    return arg(number((int)replacement), width);
-}
-
-DeprecatedString DeprecatedString::arg(unsigned short replacement, int width) const
-{
-    return arg(number((unsigned)replacement), width);
-}
-
-DeprecatedString DeprecatedString::arg(int replacement, int width) const
-{
-    return arg(number(replacement), width);
-}
-
-DeprecatedString DeprecatedString::arg(unsigned replacement, int width) const
-{
-    return arg(number(replacement), width);
-}
-
-DeprecatedString DeprecatedString::arg(long replacement, int width) const
-{
-    return arg(number(replacement), width);
-}
-
-DeprecatedString DeprecatedString::arg(unsigned long replacement, int width) const
+DeprecatedString DeprecatedString::left(unsigned len) const
 {
-    return arg(number(replacement), width);
+    return mid(0, len);
 }
 
-DeprecatedString DeprecatedString::arg(double replacement, int width) const
+DeprecatedString DeprecatedString::right(unsigned len) const
 {
-    return arg(number(replacement), width);
+    return mid(length() - len, len);
 }
 
-DeprecatedString DeprecatedString::left(unsigned len) const
-{ return mid(0, len); }
-
-
-DeprecatedString DeprecatedString::right(unsigned len) const
-{ return mid(length() - len, len); }
-
-
 DeprecatedString DeprecatedString::mid(unsigned start, unsigned len) const
 {
-    if( dataHandle && *dataHandle)
-    {
+    if (dataHandle && *dataHandle) {
         KWQStringData &data = **dataHandle;
         
         // clip length
@@ -1588,19 +1503,18 @@ DeprecatedString DeprecatedString::mid(unsigned start, unsigned len) const
                start + len <= data._length); // past the end
         
         // ascii case
-        if( data._isAsciiValid && data._ascii )
-            return DeprecatedString( &(data._ascii[start]) , len);
+        if (data._isAsciiValid && data._ascii)
+            return DeprecatedString(&data._ascii[start] , len);
         
         // unicode case
-        else if( data._isUnicodeValid && data._unicode )
-            return DeprecatedString( &(data._unicode[start]), len );
+        if (data._isUnicodeValid && data._unicode)
+            return DeprecatedString(&data._unicode[start], len);
     }
     
     // degenerate case
     return DeprecatedString();
 }
 
-
 DeprecatedString DeprecatedString::copy() const
 {
     // does not need to be a deep copy
@@ -1638,14 +1552,14 @@ DeprecatedString DeprecatedString::lower() const
                 QChar c = *p;
                 // FIXME: Doesn't work for 0x80-0xFF.
                 if (IS_ASCII_QCHAR(c)) {
-                    if (c >= 'A' && c <= 'Z') {
+                    if (c.unicode() >= 'A' && c.unicode() <= 'Z') {
                         if (!detached) {
                             s.detach();
                             d = *s.dataHandle;
                             p = d->_unicode + d->_length - l - 1;
                             detached = true;
                         }
-                        *p = c + ('a' - 'A');
+                        *p = c.unicode() + ('a' - 'A');
                     }
                 } else {
                     QChar clower = c.lower();
@@ -2033,7 +1947,7 @@ DeprecatedString &DeprecatedString::insert(unsigned index, QChar qc)
     
     if (dataHandle[0]->_isAsciiValid && IS_ASCII_QCHAR(qc)){
         unsigned originalLength = dataHandle[0]->_length;
-        char insertChar = (char)qc;
+        char insertChar = qc.unicode();
         char *targetChars;
         
         // Ensure that we have enough space.
@@ -2250,8 +2164,8 @@ DeprecatedString &DeprecatedString::replace(QChar oldChar, QChar newChar)
         if (dataHandle[0]->_isAsciiValid && IS_ASCII_QCHAR(newChar)) {
             char *p = const_cast<char *>(ascii());
             dataHandle[0]->_isUnicodeValid = 0;
-            char oldC = oldChar;
-            char newC = newChar;
+            char oldC = oldChar.unicode();
+            char newC = newChar.unicode();
             for (unsigned i = 0; i != length; ++i) {
                 if (p[i] == oldC) {
                     p[i] = newC;
@@ -2344,7 +2258,7 @@ void DeprecatedString::fill(QChar qc, int len)
             setLength(len);
             char *nd = const_cast<char*>(ascii());
             while (len--) 
-                *nd++ = (char)qc;
+                *nd++ = qc.unicode();
             dataHandle[0]->_isUnicodeValid = 0;
         } else {
             setLength(len);
@@ -2367,7 +2281,7 @@ DeprecatedString &DeprecatedString::append(QChar qc)
         return *this;
     }
     else if (thisData->_isAsciiValid && IS_ASCII_QCHAR(qc) && thisData->_length + 2 < thisData->_maxAscii){
-        thisData->_ascii[thisData->_length] = (char)qc;
+        thisData->_ascii[thisData->_length] = qc.unicode();
         thisData->_length++;
         thisData->_ascii[thisData->_length] = 0;
         thisData->_isUnicodeValid = 0;
index a563b0f..f51301f 100644 (file)
@@ -56,12 +56,6 @@ public:
         DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
     };
     
-    enum SpecialCharacter {
-        byteOrderMark = 0xfeff
-    };
-
-    static const char null = 0; // not a QChar as in Qt (can't have static constructor), but close enough to be compatible in most cases
-
     QChar();
     QChar(char);
     QChar(unsigned char);
@@ -71,10 +65,7 @@ public:
     QChar(unsigned);
 
     unsigned short unicode() const;
-    unsigned char cell() const;
-    unsigned char row() const;
     char latin1() const;
-    bool isNull() const;
     bool isSpace() const;
     bool isDigit() const;
     bool isLetter() const;
@@ -86,40 +77,8 @@ public:
     QChar upper() const;
     Direction direction() const;
 
-    bool mirrored() const;
-    QChar mirroredChar() const;
-
-    operator char() const;
-
-    friend bool operator==(QChar, QChar);
-    friend bool operator==(QChar, char);
-    friend bool operator==(char, QChar);
-
-    friend bool operator!=(QChar, QChar);
-    friend bool operator!=(QChar, char);
-    friend bool operator!=(char, QChar);
-
-    friend bool operator>(QChar, QChar);
-    friend bool operator>(QChar, char);
-    friend bool operator>(char, QChar);
-
-    friend bool operator>=(QChar, QChar);
-    friend bool operator>=(QChar, char);
-    friend bool operator>=(char, QChar);
-
-    friend bool operator<(QChar, QChar);
-    friend bool operator<(QChar, char);
-    friend bool operator<(char, QChar);
-
-    friend bool operator<=(QChar, QChar);
-    friend bool operator<=(QChar, char);
-    friend bool operator<=(char, QChar);
-
 private:
     unsigned short c;
-
-    friend class DeprecatedString;
-    friend class QConstString;
 };
 
 inline QChar::QChar() : c(0)
@@ -155,16 +114,6 @@ inline unsigned short QChar::unicode() const
     return c;
 }
 
-inline unsigned char QChar::cell() const
-{
-    return c;
-}
-
-inline bool QChar::isNull() const
-{
-    return c == 0;
-}
-
 inline bool QChar::isSpace() const
 {
     // Use isspace() for basic Latin-1.
@@ -224,119 +173,39 @@ inline QChar::Direction QChar::direction() const
     return static_cast<Direction>(u_charDirection(c));
 }
 
-inline bool QChar::mirrored() const
-{
-    return u_isMirrored(c);
-}
-
-inline QChar QChar::mirroredChar() const
-{
-    return QChar(static_cast<unsigned>(u_charMirror(c)));
-}
-
-inline unsigned char QChar::row() const
-{
-    return c >> 8;
-}
-
 inline char QChar::latin1() const
 {
     return c > 0xff ? 0 : c;
 }
 
-inline QChar::operator char() const
-{
-    return c > 0xff ? 0 : c;
-}
-
 inline bool operator==(QChar qc1, QChar qc2)
 {
-    return qc1.c == qc2.c;
+    return qc1.unicode() == qc2.unicode();
 }
 
 inline bool operator==(QChar qc, char ch)
 {
-    return qc.c == (unsigned char) ch;
+    return qc.unicode() == (unsigned char) ch;
 }
 
 inline bool operator==(char ch, QChar qc)
 {
-    return (unsigned char) ch == qc.c;
+    return (unsigned char) ch == qc.unicode();
 }
 
 inline bool operator!=(QChar qc1, QChar qc2)
 {
-    return qc1.c != qc2.c;
+    return qc1.unicode() != qc2.unicode();
 }
 
 inline bool operator!=(QChar qc, char ch)
 {
-    return qc.c != (unsigned char) ch;
+    return qc.unicode() != (unsigned char) ch;
 }
 
 inline bool operator!=(char ch, QChar qc)
 {
-    return (unsigned char) ch != qc.c;
-}
-
-inline bool operator>=(QChar qc1, QChar qc2)
-{
-    return qc1.c >= qc2.c;
-}
-
-inline bool operator>=(QChar qc, char ch)
-{
-    return qc.c >= (unsigned char) ch;
-}
-
-inline bool operator>=(char ch, QChar qc)
-{
-    return (unsigned char) ch >= qc.c;
-}
-
-inline bool operator>(QChar qc1, QChar qc2)
-{
-    return qc1.c > qc2.c;
-}
-
-inline bool operator>(QChar qc, char ch)
-{
-    return qc.c > (unsigned char) ch;
-}
-
-inline bool operator>(char ch, QChar qc)
-{
-    return (unsigned char) ch > qc.c;
-}
-
-inline bool operator<=(QChar qc1, QChar qc2)
-{
-    return qc1.c <= qc2.c;
-}
-
-inline bool operator<=(QChar qc, char ch)
-{
-    return qc.c <= (unsigned char) ch;
-}
-
-inline bool operator<=(char ch, QChar qc)
-{
-    return (unsigned char) ch <= qc.c;
-}
-
-inline bool operator<(QChar qc1, QChar qc2)
-{
-    return qc1.c < qc2.c;
-}
-
-inline bool operator<(QChar qc, char ch)
-{
-    return qc.c < (unsigned char) ch;
-}
-
-inline bool operator<(char ch, QChar qc)
-{
-    return (unsigned char) ch < qc.c;
+    return (unsigned char) ch != qc.unicode();
 }
 
 // Keep this struct to <= 46 bytes, that's what the system will allocate.
@@ -493,17 +362,6 @@ public:
     static DeprecatedString number(unsigned long);
     static DeprecatedString number(double);
 
-    bool findArg(int& pos, int& len) const;
-    
-    DeprecatedString arg(const DeprecatedString &, int width=0) const;
-    DeprecatedString arg(short, int width=0) const;
-    DeprecatedString arg(unsigned short, int width=0) const;
-    DeprecatedString arg(int, int width=0) const;
-    DeprecatedString arg(unsigned, int width=0) const;
-    DeprecatedString arg(long, int width=0) const;
-    DeprecatedString arg(unsigned long, int width=0) const;
-    DeprecatedString arg(double, int width=0) const;
-
     DeprecatedString left(unsigned) const;
     DeprecatedString right(unsigned) const;
     DeprecatedString mid(unsigned, unsigned len=0xffffffff) const;
index cc04438..b4d31e8 100644 (file)
@@ -56,9 +56,9 @@ const SegmentedString& SegmentedString::operator=(const SegmentedString &other)
 unsigned SegmentedString::length() const
 {
     unsigned length = m_currentString.m_length;
-    if (!m_pushedChar1.isNull()) {
+    if (m_pushedChar1.unicode()) {
         ++length;
-        if (!m_pushedChar2.isNull())
+        if (m_pushedChar2.unicode())
             ++length;
     }
     if (m_composite) {
@@ -118,7 +118,7 @@ void SegmentedString::append(const SegmentedString &s)
         for (; i != e; ++i)
             append(*i);
     }
-    m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
+    m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
 }
 
 void SegmentedString::prepend(const SegmentedString &s)
@@ -132,7 +132,7 @@ void SegmentedString::prepend(const SegmentedString &s)
             prepend(*i);
     }
     prepend(s.m_currentString);
-    m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
+    m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
 }
 
 void SegmentedString::advanceSubstring()
@@ -150,9 +150,9 @@ void SegmentedString::advanceSubstring()
 DeprecatedString SegmentedString::toString() const
 {
     DeprecatedString result;
-    if (!m_pushedChar1.isNull()) {
+    if (m_pushedChar1.unicode()) {
         result.append(m_pushedChar1);
-        if (!m_pushedChar2.isNull())
+        if (m_pushedChar2.unicode())
             result.append(m_pushedChar2);
     }
     m_currentString.appendTo(result);
index 3bbf83a..9654b5f 100644 (file)
 #ifndef KHTMLSTRING_H
 #define KHTMLSTRING_H
 
+#include "DeprecatedValueList.h"
 #include "PlatformString.h"
 #include <assert.h>
-#include "DeprecatedValueList.h"
 
-namespace WebCore
-{
+namespace WebCore {
 
 class SegmentedString;
 
-class SegmentedSubstring
-{
+class SegmentedSubstring {
 private:
     friend class SegmentedString;
     
@@ -64,8 +62,7 @@ private:
     const QChar *m_current;
 };
 
-class SegmentedString
-{
+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) {}
@@ -80,11 +77,11 @@ public:
     void prepend(const SegmentedString &);
     
     void push(QChar c) {
-        if (m_pushedChar1.isNull()) {
+        if (!m_pushedChar1.unicode()) {
             m_pushedChar1 = c;
-            m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current : &m_pushedChar1;
+            m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
         } else {
-            assert(m_pushedChar2.isNull());
+            assert(!m_pushedChar2.unicode());
             m_pushedChar2 = c;
         }
     }
@@ -93,7 +90,7 @@ public:
     unsigned length() const;
 
     void advance() {
-        if (!m_pushedChar1.isNull()) {
+        if (!m_pushedChar1.unicode()) {
             m_pushedChar1 = m_pushedChar2;
             m_pushedChar2 = 0;
         } else if (m_currentString.m_current) {
@@ -101,10 +98,10 @@ public:
             if (--m_currentString.m_length == 0)
                 advanceSubstring();
         }
-        m_currentChar = m_pushedChar1.isNull() ? m_currentString.m_current: &m_pushedChar1;
+        m_currentChar = m_pushedChar1.unicode() ? &m_pushedChar1 : m_currentString.m_current;
     }
     
-    bool escaped() const { return !m_pushedChar1.isNull(); }
+    bool escaped() const { return m_pushedChar1.unicode(); }
 
     int lineCount() const { return m_lines; }
     void resetLineCount() { m_lines = 0; }
index cee396f..fe27cfe 100644 (file)
@@ -286,9 +286,9 @@ Length* StringImpl::toCoordsArray(int& len) const
 {
     QChar* spacified = newQCharVector(m_length);
     QChar space(' ');
-    for(unsigned int i=0; i < m_length; i++) {
+    for (unsigned int i=0; i < m_length; i++) {
         QChar cc = m_data[i];
-        if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.'))
+        if (cc.unicode() > '9' || (cc.unicode() < '0' && cc != '-' && cc != '*' && cc != '.'))
             spacified[i] = space;
         else
             spacified[i] = cc;
index 8772832..4ffac3e 100644 (file)
@@ -106,7 +106,7 @@ static String getCharset(const String& contentTypeString)
             return String();
         
         // is what we found a beginning of a word?
-        if (contentTypeString[pos-1] > ' ' && contentTypeString[pos-1] != ';') {
+        if (contentTypeString[pos-1].unicode() > ' ' && contentTypeString[pos-1] != ';') {
             pos += 7;
             continue;
         }
@@ -114,18 +114,18 @@ static String getCharset(const String& contentTypeString)
         pos += 7;
 
         // skip whitespace
-        while (pos != length && contentTypeString[pos] <= ' ')
+        while (pos != length && contentTypeString[pos].unicode() <= ' ')
             ++pos;
     
         if (contentTypeString[pos++] != '=') // this "charset" substring wasn't a parameter name, but there may be others
             continue;
 
-        while (pos != length && (contentTypeString[pos] <= ' ' || contentTypeString[pos] == '"' || contentTypeString[pos] == '\''))
+        while (pos != length && (contentTypeString[pos].unicode() <= ' ' || 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] > ' ' && contentTypeString[endpos] != '"' && contentTypeString[endpos] != '\'' && contentTypeString[endpos] != ';')
+        while (pos != length && contentTypeString[endpos].unicode() > ' ' && contentTypeString[endpos] != '"' && contentTypeString[endpos] != '\'' && contentTypeString[endpos] != ';')
             ++endpos;
     
         return contentTypeString.substring(pos, endpos-pos);