Changeset 561 for trunk/src/corelib/io/qurl.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/io/qurl.cpp (modified) (102 diffs)

trunk/src/corelib/io/qurl.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -48 +48 @@
     \reentrant
     \ingroup io
-    \ingroup misc
+    \ingroup 
     \ingroup shared
-    \mainclass
+
 
     It can parse and construct URLs in both encoded and unencoded
@@ -173 +173 @@
 #include "qatomic.h"
 #include "qbytearray.h"
+
+
 #include "qlist.h"
 #ifndef QT_NO_REGEXP
@@ -2337 +2339 @@
 };
 
-static void mapToLowerCase(QString *str)
+static void mapToLowerCase(QString *str)
 {
     int N = sizeof(NameprepCaseFolding) / sizeof(NameprepCaseFolding[0]);
 
     QChar *d = 0;
-    for (int i = 0; i < str->size(); ++i) {
+    for (int i = ; i < str->size(); ++i) {
         int uc = str->at(i).unicode();
         if (uc < 0x80) {
@@ -2389 +2391 @@
 
 
-static void stripProhibitedOutput(QString *str)
-{
-    ushort *out = (ushort *)str->data(); 
+static void stripProhibitedOutput(QString *str)
+{
+    ushort *out = (ushort *)str->data()
     const ushort *in = out;
-    const ushort *end = out + str->size();
+    const ushort *end =  + str->size();
     while (in < end) {
         ushort uc = *in;
@@ -2902 +2904 @@
 }
 
-
-Q_AUTOTEST_EXPORT QString qt_nameprep(const QString &source)
-{
-    QString mapped = source;
-    
-    bool simple = true;
-    for (int i = 0; i < mapped.size(); ++i) {
-        ushort uc = mapped.at(i).unicode();
+#ifdef QT_BUILD_INTERNAL
+// export for tst_qurl.cpp
+Q_AUTOTEST_EXPORT void qt_nameprep(QString *source, int from);
+Q_AUTOTEST_EXPORT bool qt_check_std3rules(const QChar *uc, int len);
+#else
+// non-test build, keep the symbols for ourselves
+static void qt_nameprep(QString *source, int from);
+static bool qt_check_std3rules(const QChar *uc, int len);
+#endif
+
+void qt_nameprep(QString *source, int from)
+{
+    QChar *src = source->data(); // causes a detach, so we're sure the only one using it
+    QChar *out = src + from;
+    const QChar *e = src + source->size();
+
+    for ( ; out < e; ++out) {
+        register ushort uc = out->unicode();
         if (uc > 0x80) {
-            simple = false;
             break;
         } else if (uc >= 'A' && uc <= 'Z') {
-            mapped[i] = QChar(uc | 0x20);
+             = QChar(uc | 0x20);
         }
     }
-    if (simple)
-        return mapped;
-    
+    if (out == e)
+        return; // everything was mapped easily (lowercased, actually)
+    int firstNonAscii = out - src;
+
     // Characters commonly mapped to nothing are simply removed
     // (Table B.1)
-    QChar *out = mapped.data();
     const QChar *in = out;
-    const QChar *e = in + mapped.size();
     while (in < e) {
         if (!isMappedToNothing(*in))
@@ -2931 +2941 @@
     }
     if (out != in)
-        mapped.truncate(out - mapped.constData());
+        );
 
     // Map to lowercase (Table B.2)
-    mapToLowerCase(&mapped);
+    mapToLowerCase();
 
     // Normalize to Unicode 3.2 form KC
-    mapped = mapped.normalized(QString::NormalizationForm_KC, QChar::Unicode_3_2);
+    extern void qt_string_normalize(QString *data, QString::NormalizationForm mode,
+                                    QChar::UnicodeVersion version, int from);
+    qt_string_normalize(source, QString::NormalizationForm_KC, QChar::Unicode_3_2, firstNonAscii);
 
     // Strip prohibited output
-    stripProhibitedOutput(&mapped);
+    stripProhibitedOutput();
 
     // Check for valid bidirectional characters
     bool containsLCat = false;
     bool containsRandALCat = false;
-    for (int j = 0; j < mapped.size() && (!containsLCat || !containsRandALCat); ++j) {
-        if (isBidirectionalL(mapped.at(j)))
+    src = source->data();
+    e = src + source->size();
+    for (in = src + from; in < e && (!containsLCat || !containsRandALCat); ++in) {
+        if (isBidirectionalL(*in))
             containsLCat = true;
-        else if (isBidirectionalRorAL(mapped.at(j)))
+        else if (isBidirectionalRorAL())
             containsRandALCat = true;
     }
     if (containsRandALCat) {
-        if (containsLCat || (!isBidirectionalRorAL(mapped.at(0))
-                             || !isBidirectionalRorAL(mapped.at(mapped.size() - 1))))
-            mapped.clear();
-    }
-
-    return mapped;
-}
-
-
-static inline char encodeDigit(uint digit)
+        if (containsLCat || (!isBidirectionalRorAL(src[from])
+                             || !isBidirectionalRorAL(e[-1])))
+            source->resize(from); // not allowed, clear the label
+    }
+}
+
+bool qt_check_std3rules(const QChar *uc, int len)
+{
+    if (len > 63)
+        return false;
+
+    for (int i = 0; i < len; ++i) {
+        register ushort c = uc[i].unicode();
+        if (c == '-' && (i == 0 || i == len - 1))
+            return false;
+
+        // verifying the absence of LDH is the same as verifying that
+        // only LDH is present
+        if (c == '-' || (c >= '0' && c <= '9')
+            || (c >= 'A' && c <= 'Z')
+            || (c >= 'a' && c <= 'z'))
+            continue;
+
+        return false;
+    }
+
+    return true;
+}
+
+
+static inline uint encodeDigit(uint digit)
 {
   return digit + 22 + 75 * (digit < 26);
@@ -2978 +3013 @@
 }
 
-static inline void appendEncode(QByteArray* output, uint& delta, uint& bias, uint& b, uint& h)
+static inline void appendEncode(Q* output, uint& delta, uint& bias, uint& b, uint& h)
 {
     uint qq;
@@ -2992 +3027 @@
         if (qq < t) break;
 
-        *output += encodeDigit(t + (qq - t) % (base - t));
+        *output += ));
         qq = (qq - t) / (base - t);
     }
 
-    *output += encodeDigit(qq);
+    *output += );
     bias = adapt(delta, h + 1, h == b);
     delta = 0;
@@ -3002 +3037 @@
 }
 
-static void toPunycodeHelper(const QChar *s, int ucLength, QByteArray *output)
+static void toPunycodeHelper(const QChar *s, int ucLength, Q *output)
 {
     uint n = initial_n;
@@ -3011 +3046 @@
     output->resize(outLen + ucLength);
 
-    char *d = output->data() + outLen;
+    har *d = output->data() + outLen;
     bool skipped = false;
     // copy all basic code points verbatim to output.
@@ -3036 +3071 @@
     // if basic code points were copied, add the delimiter character.
     if (h > 0)
-        *output += 0x2d;
+        *output += ;
 
     // while there are still unprocessed non-basic code points left in
@@ -3084 +3119 @@
 
     // prepend ACE prefix
-    output->insert(outLen, "xn--");
+    output->insert(outLen, );
     return;
 }
@@ -3145 +3180 @@
     if (idx == -1)
         return false;
-    const QChar *tld = domain.constData() + idx + 1;
+
     int len = domain.size() - idx - 1;
+
+
+
+
 
     if (user_idn_whitelist)
-        return user_idn_whitelist->contains(QString(tld, len));
+        return user_idn_whitelist->contains();
 
     int l = 0;
@@ -3165 +3204 @@
 }
 
-static QString qt_from_ACE(const QString &domainMC)
-{
-    QString domain = domainMC.toLower();
-    int idx = domain.indexOf(QLatin1Char('.'));
-    if (idx != -1) {
-        if (!domain.contains(QLatin1String("xn--"))) {
-            bool simple = true;
-            for (int i = 0; i < domain.size(); ++i) {
-                ushort ch = domain.at(i).unicode();
-                if (ch > 'z' || ch < '-' || ch == '/' || (ch > '9' && ch < 'A') || (ch > 'Z' && ch < 'a')) {
+static inline bool isDotDelimiter(ushort uc)
+{
+    // IDNA / rfc3490 describes these four delimiters used for
+    // separating labels in unicode international domain
+    // names.
+    return uc == 0x2e || uc == 0x3002 || uc == 0xff0e || uc == 0xff61;
+}
+
+static int nextDotDelimiter(const QString &domain, int from = 0)
+{
+    const QChar *b = domain.unicode();
+    const QChar *ch = b + from;
+    const QChar *e = b + domain.length();
+    while (ch < e) {
+        if (isDotDelimiter(ch->unicode()))
+            break;
+        else
+            ++ch;
+    }
+    return ch - b;
+}
+
+enum AceOperation { ToAceOnly, NormalizeAce };
+static QString qt_ACE_do(const QString &domain, AceOperation op)
+{
+    if (domain.isEmpty())
+        return domain;
+
+    QString result;
+    result.reserve(domain.length());
+
+    const bool isIdnEnabled = op == NormalizeAce ? qt_is_idn_enabled(domain) : false;
+    int lastIdx = 0;
+    QString aceForm; // this variable is here for caching
+
+    while (1) {
+        int idx = nextDotDelimiter(domain, lastIdx);
+        int labelLength = idx - lastIdx;
+        if (labelLength == 0)
+            return QString(); // two delimiters in a row -- empty label not allowed
+
+        // RFC 3490 says, about the ToASCII operation:
+        //   3. If the UseSTD3ASCIIRules flag is set, then perform these checks:
+        //
+        //     (a) Verify the absence of non-LDH ASCII code points; that is, the
+        //         absence of 0..2C, 2E..2F, 3A..40, 5B..60, and 7B..7F.
+        //
+        //     (b) Verify the absence of leading and trailing hyphen-minus; that
+        //         is, the absence of U+002D at the beginning and end of the
+        //         sequence.
+        // and:
+        //   8. Verify that the number of code points is in the range 1 to 63
+        //      inclusive.
+
+        // copy the label to the destination, which also serves as our scratch area, lowercasing it
+        int prevLen = result.size();
+        bool simple = true;
+        result.resize(prevLen + labelLength);
+        {
+            QChar *out = result.data() + prevLen;
+            const QChar *in = domain.constData() + lastIdx;
+            const QChar *e = in + labelLength;
+            for (; in < e; ++in, ++out) {
+                register ushort uc = in->unicode();
+                if (uc > 0x7f)
                     simple = false;
-                    break;
-                }
+                if (uc >= 'A' && uc <= 'Z')
+                    *out = QChar(uc | 0x20);
+                else
+                    *out = *in;
             }
-            if (simple)
-                return domain;
         }
-        
-        const bool isIdnEnabled = qt_is_idn_enabled(domain);
-        int lastIdx = 0;
-        QString result;
-        while (1) {
-            // Nameprep the host. If the labels in the hostname are Punycode
-            // encoded, we decode them immediately, then nameprep them.
-            QByteArray label;
-            toPunycodeHelper(domain.constData() + lastIdx, idx - lastIdx, &label);
-            result += qt_nameprep(isIdnEnabled ? QUrl::fromPunycode(label) : QString::fromLatin1(label));
-            lastIdx = idx + 1;
-            if (lastIdx < domain.size() + 1)
-                result += QLatin1Char('.');
-            else
-                break;
-            idx = domain.indexOf(QLatin1Char('.'), lastIdx);
-            if (idx == -1)
-                idx = domain.size();
+
+        if (simple && labelLength > 6) {
+            // ACE form domains contain only ASCII characters, but we can't consider them simple
+            // is this an ACE form?
+            // the shortest valid ACE domain is 6 characters long (U+0080 would be 1, but it's not allowed)
+            static const ushort acePrefixUtf16[] = { 'x', 'n', '-', '-' };
+            if (memcmp(result.constData() + prevLen, acePrefixUtf16, sizeof acePrefixUtf16) == 0)
+                simple = false;
         }
-        return result;
-    } else {
-        return qt_nameprep(domain);
-    }
+
+        if (simple) {
+            // fastest case: this is the common case (non IDN-domains)
+            // so we're done
+            if (!qt_check_std3rules(result.constData() + prevLen, labelLength))
+                return QString();
+        } else { 
+            // Punycode encoding and decoding cannot be done in-place
+            // That means we need one or two temporaries
+            qt_nameprep(&result, prevLen);
+            labelLength = result.length() - prevLen;
+            register int toReserve = labelLength + 4 + 6; // "xn--" plus some extra bytes
+            if (toReserve > aceForm.capacity())
+                aceForm.reserve(toReserve);
+            toPunycodeHelper(result.constData() + prevLen, result.size() - prevLen, &aceForm);
+
+            // We use resize()+memcpy() here because we're overwriting the data we've copied
+            if (isIdnEnabled) {
+                QString tmp = QUrl::fromPunycode(aceForm.toLatin1());
+                if (tmp.isEmpty())
+                    return QString(); // shouldn't happen, since we've just punycode-encoded it
+                result.resize(prevLen + tmp.size());
+                memcpy(result.data() + prevLen, tmp.constData(), tmp.size() * sizeof(QChar));
+            } else {
+                result.resize(prevLen + aceForm.size());
+                memcpy(result.data() + prevLen, aceForm.constData(), aceForm.size() * sizeof(QChar));
+            }
+
+            if (!qt_check_std3rules(aceForm.constData(), aceForm.size()))
+                return QString();
+        }
+
+
+        lastIdx = idx + 1;
+        if (lastIdx < domain.size() + 1)
+            result += QLatin1Char('.');
+        else
+            break;
+    }
+    return result;
 }
 
@@ -3247 +3367 @@
 QString QUrlPrivate::canonicalHost() const
 {
-    if (QURL_HASFLAG(stateFlags, HostCanonicalized))
+    if (QURL_HASFLAG(stateFlags, HostCanonicalized))
         return host;
 
     QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
     QURL_SETFLAG(that->stateFlags, HostCanonicalized);
-    that->host = qt_from_ACE(host);
+    if (host.contains(QLatin1Char(':'))) {
+        // This is an IP Literal, use _IPLiteral to validate
+        QByteArray ba = host.toLatin1();
+        if (!ba.startsWith('[')) {
+            // surround the IP Literal with [ ] if it's not already done so
+            ba.reserve(ba.length() + 2);
+            ba.prepend('[');
+            ba.append(']');
+        }
+
+        const char *ptr = ba.constData();
+        if (!_IPLiteral(&ptr))
+            that->host.clear();
+        else
+            that->host = host.toLower();
+    } else {
+        that->host = qt_ACE_do(host, NormalizeAce);
+    }
     return that->host;
 }
@@ -3728 +3865 @@
 
         if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
+
             if (!userName.isEmpty()) {
                 url += encodedUserName;
-                if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
-                    url += ':';
-                    url += encodedPassword;
-                }
+                hasUserOrPass = true;
+            }
+            if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
+                url += ':';
+                url += encodedPassword;
+                hasUserOrPass = true;
+            }
+            if (hasUserOrPass)
                 url += '@';
-            }
         }
 
-        url += QUrl::toAce(host);
+        if (host.startsWith(QLatin1Char('['))) {
+            url += host.toLatin1();
+        } else if (host.contains(QLatin1Char(':'))) {
+            url += '[';
+            url += host.toLatin1();
+            url += ']';
+        } else {
+            url += QUrl::toAce(host);
+        }
         if (!(options & QUrl::RemovePort) && port != -1) {
             url += ':';
@@ -3889 +4038 @@
 
 /*!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Constructs a URL by parsing \a url. \a url is assumed to be in human
     readable representation, with no percent encoding. QUrl will automatically
@@ -3903 +4075 @@
     \sa setUrl(), setEncodedUrl(), fromEncoded(), TolerantMode
 */
-QUrl::QUrl(const QString &url) : d(new QUrlPrivate)
+QUrl::QUrl(const QString &url) : d()
 {
     if (!url.isEmpty())
@@ -3916 +4088 @@
     \sa setUrl()
 */
-QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d(new QUrlPrivate)
+QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d()
 {
     if (!url.isEmpty())
         setUrl(url, parsingMode);
-    else
+    else {
+        d = new QUrlPrivate;
         d->parsingMode = parsingMode;
+
 }
 
@@ -3927 +4101 @@
     Constructs an empty QUrl object.
 */
-QUrl::QUrl() : d(new QUrlPrivate)
+QUrl::QUrl() : d()
 {
 }
@@ -3936 +4110 @@
 QUrl::QUrl(const QUrl &other) : d(other.d)
 {
-    d->ref.ref();
+    if (d)
+        d->ref.ref();
 }
 
@@ -3944 +4119 @@
 QUrl::~QUrl()
 {
-    if (!d->ref.deref())
+    if (!d->ref.deref())
         delete d;
 }
@@ -3959 +4134 @@
 bool QUrl::isValid() const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
@@ -3970 +4147 @@
 bool QUrl::isEmpty() const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed))
         return d->encodedOriginal.isEmpty();
@@ -3990 +4169 @@
 void QUrl::clear()
 {
-    detach();
-    d->clear();
+    if (d && !d->ref.deref())
+        delete d;
+    d = 0;
 }
 
@@ -4090 +4270 @@
 void QUrl::setEncodedUrl(const QByteArray &encodedUrl, ParsingMode parsingMode)
 {
-    clear();
     QByteArray tmp = encodedUrl;
+
+
     if ((d->parsingMode = parsingMode) == TolerantMode) {
         // Replace stray % with %25
@@ -4165 +4346 @@
 void QUrl::setScheme(const QString &scheme)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4180 +4362 @@
 QString QUrl::scheme() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4203 +4386 @@
 void QUrl::setAuthority(const QString &authority)
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4218 +4403 @@
 QString QUrl::authority() const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4238 +4425 @@
 void QUrl::setUserInfo(const QString &userInfo)
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4251 +4440 @@
 QString QUrl::userInfo() const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4265 +4456 @@
 void QUrl::setUserName(const QString &userName)
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4281 +4474 @@
 QString QUrl::userName() const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4302 +4497 @@
 void QUrl::setEncodedUserName(const QByteArray &userName)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4322 +4518 @@
 QByteArray QUrl::encodedUserName() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4337 +4534 @@
 void QUrl::setPassword(const QString &password)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4353 +4551 @@
 QString QUrl::password() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4374 +4573 @@
 void QUrl::setEncodedPassword(const QByteArray &password)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4394 +4594 @@
 QByteArray QUrl::encodedPassword() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4408 +4609 @@
 void QUrl::setHost(const QString &host)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4413 +4615 @@
 
     d->host = host;
-    if (d->host.contains(QLatin1Char(':')))
-        d->host = QLatin1Char('[') + d->host + QLatin1Char(']');
 }
 
@@ -4423 +4623 @@
 QString QUrl::host() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4476 +4677 @@
 void QUrl::setPort(int port)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4493 +4695 @@
 int QUrl::port() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
@@ -4511 +4714 @@
 int QUrl::port(int defaultPort) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     return d->port == -1 ? defaultPort : d->port;
@@ -4530 +4734 @@
 void QUrl::setPath(const QString &path)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4545 +4750 @@
 QString QUrl::path() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4576 +4782 @@
 void QUrl::setEncodedPath(const QByteArray &path)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4596 +4803 @@
 QByteArray QUrl::encodedPath() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4611 +4819 @@
 bool QUrl::hasQuery() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4640 +4849 @@
 void QUrl::setQueryDelimiters(char valueDelimiter, char pairDelimiter)
 {
+
     detach();
 
@@ -4652 +4862 @@
 char QUrl::queryPairDelimiter() const
 {
+
     return d->pairDelimiter;
 }
@@ -4661 +4872 @@
 char QUrl::queryValueDelimiter() const
 {
+
     return d->valueDelimiter;
 }
@@ -4683 +4895 @@
 void QUrl::setEncodedQuery(const QByteArray &query)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4702 +4915 @@
 void QUrl::setQueryItems(const QList<QPair<QString, QString> > &query)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4741 +4955 @@
 void QUrl::setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4760 +4975 @@
     URL.
 
+
+
+
+
+
+
     \sa addEncodedQueryItem()
 */
 void QUrl::addQueryItem(const QString &key, const QString &value)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4798 +5020 @@
 void QUrl::addEncodedQueryItem(const QByteArray &key, const QByteArray &value)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -4818 +5041 @@
 QList<QPair<QString, QString> > QUrl::queryItems() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4850 +5074 @@
 QList<QPair<QByteArray, QByteArray> > QUrl::encodedQueryItems() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4878 +5103 @@
 bool QUrl::hasQueryItem(const QString &key) const
 {
+
     return hasEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
 }
@@ -4896 +5122 @@
 bool QUrl::hasEncodedQueryItem(const QByteArray &key) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4918 +5145 @@
 QString QUrl::queryItemValue(const QString &key) const
 {
+
     QByteArray tmp = encodedQueryItemValue(toPercentEncoding(key, queryExcludeChars));
     return fromPercentEncodingMutable(&tmp);
@@ -4937 +5165 @@
 QByteArray QUrl::encodedQueryItemValue(const QByteArray &key) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4960 +5189 @@
 QStringList QUrl::allQueryItemValues(const QString &key) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -4997 +5227 @@
 QList<QByteArray> QUrl::allEncodedQueryItemValues(const QByteArray &key) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5024 +5255 @@
 void QUrl::removeQueryItem(const QString &key)
 {
+
     removeEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
 }
@@ -5042 +5274 @@
 void QUrl::removeEncodedQueryItem(const QByteArray &key)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -5068 +5301 @@
 void QUrl::removeAllQueryItems(const QString &key)
 {
+
     removeAllEncodedQueryItems(toPercentEncoding(key, queryExcludeChars));
 }
@@ -5086 +5320 @@
 void QUrl::removeAllEncodedQueryItems(const QByteArray &key)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -5109 +5344 @@
 QByteArray QUrl::encodedQuery() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5133 +5369 @@
 void QUrl::setFragment(const QString &fragment)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -5149 +5386 @@
 QString QUrl::fragment() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5179 +5417 @@
 void QUrl::setEncodedFragment(const QByteArray &fragment)
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     detach();
@@ -5200 +5439 @@
 QByteArray QUrl::encodedFragment() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5215 +5455 @@
 bool QUrl::hasFragment() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5241 +5482 @@
 QUrl QUrl::resolved(const QUrl &relative) const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5257 +5500 @@
             t = relative;
         } else {
+
             if (relative.d->encodedPath.isEmpty()) {
                 t.d->encodedPath = d->encodedPath;
@@ -5287 +5531 @@
 bool QUrl::isRelative() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5301 +5546 @@
 QString QUrl::toString(FormattingOptions options) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
@@ -5325 +5571 @@
         url += ourPath;
         // check if we need to remove trailing slashes
-        while ((options & StripTrailingSlash) && url.right(1) == QLatin1String("/"))
+        while ((options & StripTrailingSlash) && url.))
             url.chop(1);
     }
@@ -5352 +5598 @@
 QByteArray QUrl::toEncoded(FormattingOptions options) const
 {
+
     return d->toEncoded(options);
 }
@@ -5420 +5667 @@
 QByteArray QUrl::toPunycode(const QString &uc)
 {
-    QByteArray output;
+    Q output;
     toPunycodeHelper(uc.constData(), uc.size(), &output);
-    return output;
+    return output;
 }
 
@@ -5518 +5765 @@
     and RFC 3492. It is part of the Internationalizing Domain Names in
     Applications (IDNA) specification, which allows for domain names
-    (like \c "qtsoftware.com") to be written using international
+    (like \c "e.com") to be written using international
     characters.
 */
 QString QUrl::fromAce(const QByteArray &domain)
 {
-    return qt_from_ACE(QString::fromLatin1(domain));
+    return qt_);
 }
 
@@ -5535 +5782 @@
     and RFC 3492. It is part of the Internationalizing Domain Names in
     Applications (IDNA) specification, which allows for domain names
-    (like \c "qtsoftware.com") to be written using international
+    (like \c "e.com") to be written using international
     characters.
+
+
+
+
 */
 QByteArray QUrl::toAce(const QString &domain)
 {
-    // IDNA / rfc3490 describes these four delimiters used for
-    // separating labels in unicode international domain
-    // names.
-    QString nameprepped = qt_nameprep(domain);
-    int lastIdx = 0;
-    QByteArray result;
-    for (int i = 0; i < nameprepped.size(); ++i) {
-        ushort uc = nameprepped.at(i).unicode();
-        if (uc == 0x2e || uc == 0x3002 || uc == 0xff0e || uc == 0xff61) {
-            if (lastIdx)
-                result += '.';
-            toPunycodeHelper(nameprepped.constData() + lastIdx, i - lastIdx, &result);
-            lastIdx = i + 1;
-        }
-    }
-    if (lastIdx)
-        result += '.';
-    toPunycodeHelper(nameprepped.constData() + lastIdx, nameprepped.size() - lastIdx, &result);
-    
-    return result;
+    QString result = qt_ACE_do(domain, ToAceOnly);
+    return result.toLatin1();
 }
 
@@ -5616 +5849 @@
 bool QUrl::operator <(const QUrl &url) const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
     if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
     return d->normalized() < url.d->normalized();
@@ -5627 +5862 @@
 bool QUrl::operator ==(const QUrl &url) const
 {
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
     if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
@@ -5646 +5883 @@
 QUrl &QUrl::operator =(const QUrl &url)
 {
-    qAtomicAssign(d, url.d);
+    if (!d) {
+        if (url.d) {
+            url.d->ref.ref();
+            d = url.d;
+        }
+    } else {
+        if (url.d)
+            qAtomicAssign(d, url.d);
+        else
+            clear();
+    }
     return *this;
 }
@@ -5655 +5902 @@
 QUrl &QUrl::operator =(const QString &url)
 {
-    QUrl tmp(url);
-    qAtomicAssign(d, tmp.d);
+    if (url.isEmpty()) {
+        clear();
+    } else {
+        QUrl tmp(url);
+        if (!d) d = new QUrlPrivate;
+        qAtomicAssign(d, tmp.d);
+    }
     return *this;
 }
@@ -5665 +5917 @@
 */
 void QUrl::detach()
-{ qAtomicDetach(d); }
+{
+    if (!d)
+        d = new QUrlPrivate;
+    else
+        qAtomicDetach(d);
+}
 
 /*!
@@ -5672 +5929 @@
 bool QUrl::isDetached() const
 {
-    return d->ref == 1;
+    return d->ref == 1;
 }
 
@@ -5693 +5950 @@
     // magic for drives on windows
     if (deslashified.length() > 1 && deslashified.at(1) == QLatin1Char(':') && deslashified.at(0) != QLatin1Char('/')) {
-        url.setPath(QLatin1String("/") + deslashified);
+        url.setPath(QLatin1) + deslashified);
     // magic for shared drive on windows
     } else if (deslashified.startsWith(QLatin1String("//"))) {
@@ -5714 +5971 @@
 QString QUrl::toLocalFile() const
 {
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
     QString tmp;
     QString ourPath = path();
-    if (d->scheme.isEmpty() || d->scheme.toLower() == QLatin1String("file")) {
+    if (d->scheme.isEmpty() || ) {
 
         // magic for shared drive on windows
         if (!d->host.isEmpty()) {
             tmp = QLatin1String("//") + d->host + (ourPath.length() > 0 && ourPath.at(0) != QLatin1Char('/')
-                                                  ? QLatin1String("/") + ourPath :  ourPath);
+                                                  ? QLatin1) + ourPath :  ourPath);
         } else {
             tmp = ourPath;
@@ -5742 +6000 @@
 bool QUrl::isParentOf(const QUrl &childUrl) const
 {
+
+
+
+
+
+
+
     if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 
-    QString childPath = childUrl.path();
     QString ourPath = path();
 
@@ -5845 +6109 @@
 
     \oldcode
-        QUrl url("http://qtsoftware.com/Developer/");
+        QUrl url("http://e.com/Developer/");
         url.cdUp();
     \newcode
-        QUrl url("http://qtsoftware.com/Developer/");
+        QUrl url("http://e.com/Developer/");
         url = url.resolved("..");
     \endcode
@@ -5971 +6235 @@
 QDebug operator<<(QDebug d, const QUrl &url)
 {
-    d.maybeSpace() << "QUrl(" << url.toString() << ")";
+    d.maybeSpace() << "QUrl(" << url.toString() << ;
     return d.space();
 }
@@ -5984 +6248 @@
 QString QUrl::errorString() const
 {
+
+
     return d->createErrorString();
 }
@@ -5997 +6263 @@
 */
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QT_END_NAMESPACE