Long live the new QUrl implementation.

Also say hello to QUrl's constructor and QUrl::toString being allowed
again.

QUrl operates now on UTF-16 encoded data, where a Unicode character
matches its UTF-8 percent-encoded form (as per RFC 3987). The data may
exist in different levels of encoding, but it is always in encoded
form (a percent is always "%25"). For that reason, the previously
dangerous methods are no longer dangerous.

The QUrl parser is much more lenient now. Instead of blindly following
the grammar from RFC 3986, we try to use common-sense. Hopefully, this
will also mean the code is faster. It also operates on QStrings and,
for the common case, will not perform any memory allocations it
doesn't keep (i.e., it allocates only for the data that is stored in
QUrlPrivate).

The Null/Empty behaviour that fragments and queries had in Qt4 are now
extended to the scheme, username, password and host parts. This means
QUrl can remember the difference between "http://@example.com" and
"http://example.com".

Missing from this commit:
 - more unit tests, for the new functionality
 - the implementation of the StrictMode parser
 - errorString() support
 - normalisation

Change-Id: I6d340b19c1a11b98a48145152513ffec58fb3fe3
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

1 files changed, 78 insertions, 22 deletions

diff --git a/src/corelib/io/qurl_p.h b/src/corelib/io/qurl_p.h
index 05f3fe13af..6a0af1c90a 100644
--- a/src/corelib/io/qurl_p.h
+++ b/src/corelib/io/qurl_p.h
@@ -75,29 +75,89 @@ struct QUrlErrorInfo {
     }
 };
 
-struct QUrlParseData
+class QUrlPrivate
 {
-    const char *scheme;
-    int schemeLength;
-
-    const char *userInfo;
-    int userInfoDelimIndex;
-    int userInfoLength;
-
-    const char *host;
-    int hostLength;
+public:
+    enum Section {
+        Scheme = 0x01,
+        UserName = 0x02,
+        Password = 0x04,
+        UserInfo = UserName | Password,
+        Host = 0x08,
+        Port = 0x10,
+        Authority = UserInfo | Host | Port,
+        Path = 0x20,
+        Hierarchy = Authority | Path,
+        Query = 0x40,
+        Fragment = 0x80
+    };
+
+    QUrlPrivate();
+    QUrlPrivate(const QUrlPrivate &copy);
+
+    void parse(const QString &url);
+    void clear();
+
+    // no QString scheme() const;
+    void appendAuthority(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendUserInfo(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendUserName(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendPassword(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendHost(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendPath(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendQuery(QString &appendTo, QUrl::FormattingOptions options) const;
+    void appendFragment(QString &appendTo, QUrl::FormattingOptions options) const;
+
+    // the "end" parameters are like STL iterators: they point to one past the last valid element
+    bool setScheme(const QString &value, int len, bool decoded = false);
+    bool setAuthority(const QString &auth, int from, int end);
+    void setUserInfo(const QString &userInfo, int from, int end);
+    void setUserName(const QString &value, int from, int end);
+    void setPassword(const QString &value, int from, int end);
+    bool setHost(const QString &value, int from, int end, bool maybePercentEncoded = true);
+    void setPath(const QString &value, int from, int end);
+    void setQuery(const QString &value, int from, int end);
+    void setFragment(const QString &value, int from, int end);
+
+    inline bool hasScheme() const { return sectionIsPresent & Scheme; }
+    inline bool hasAuthority() const { return sectionIsPresent & Authority; }
+    inline bool hasUserInfo() const { return sectionIsPresent & UserInfo; }
+    inline bool hasUserName() const { return sectionIsPresent & UserName; }
+    inline bool hasPassword() const { return sectionIsPresent & Password; }
+    inline bool hasHost() const { return sectionIsPresent & Host; }
+    inline bool hasPort() const { return port != -1; }
+    inline bool hasPath() const { return !path.isEmpty(); }
+    inline bool hasQuery() const { return sectionIsPresent & Query; }
+    inline bool hasFragment() const { return sectionIsPresent & Fragment; }
+
+    QString mergePaths(const QString &relativePath) const;
+
+    QAtomicInt ref;
     int port;
 
-    const char *path;
-    int pathLength;
-    const char *query;
-    int queryLength;
-    const char *fragment;
-    int fragmentLength;
-
-    QUrlErrorInfo *errorInfo;
+    QString scheme;
+    QString userName;
+    QString password;
+    QString host;
+    QString path;
+    QString query;
+    QString fragment;
+
+    // not used for:
+    //  - Port (port == -1 means absence)
+    //  - Path (there's no path delimiter, so we optimize its use out of existence)
+    // Schemes are never supposed to be empty, but we keep the flag anyway
+    uchar sectionIsPresent;
+
+    // UserName, Password, Path, Query, and Fragment never contain errors in TolerantMode.
+    // Those flags are set only by the strict parser.
+    uchar sectionHasError;
+
+    mutable QUrlErrorInfo errorInfo;
+    QString createErrorString();
 };
 
+
 // in qurlrecode.cpp
 extern Q_AUTOTEST_EXPORT int qt_urlRecode(QString &appendTo, const QChar *begin, const QChar *end,
                                           QUrl::ComponentFormattingOptions encoding, const ushort *tableModifications);
@@ -110,10 +170,6 @@ extern Q_AUTOTEST_EXPORT bool qt_check_std3rules(const QChar *uc, int len);
 extern Q_AUTOTEST_EXPORT void qt_punycodeEncoder(const QChar *s, int ucLength, QString *output);
 extern Q_AUTOTEST_EXPORT QString qt_punycodeDecoder(const QString &pc);
 
-// in qurlparser.cpp
-extern bool qt_urlParse(const char *ptr, QUrlParseData &parseData);
-extern bool qt_isValidUrlIP(const char *ptr);
-
 QT_END_NAMESPACE
 
 #endif // QURL_P_H