qurl.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qurl.h"
#include "qurl_p.h"
#include "qplatformdefs.h"
#include "qstring.h"
#include "qstringlist.h"
#include "qdebug.h"
#include "qhash.h"
#include "qdatastream.h"
#include "private/qipaddress_p.h"
#include "qurlquery.h"
#include "private/qdir_p.h"
#include <private/qtools_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace QtMiscUtils;
 
inline static bool isHex(char c)
{
    c |= 0x20;
    return isAsciiDigit(c) || (c >= 'a' && c <= 'f');
}
 
static inline QString ftpScheme()
{
    return QStringLiteral("ftp");
}
 
static inline QString fileScheme()
{
    return QStringLiteral("file");
}
 
static inline QString webDavScheme()
{
    return QStringLiteral("webdavs");
}
 
static inline QString webDavSslTag()
{
    return QStringLiteral("@SSL");
}
 
class QUrlPrivate
{
public:
    enum Section : uchar {
        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,
        FullUrl = 0xff
    };
 
    enum Flags : uchar {
        IsLocalFile = 0x01
    };
 
    enum ErrorCode {
        // the high byte of the error code matches the Section
        // the first item in each value must be the generic "Invalid xxx Error"
        InvalidSchemeError = Scheme << 8,
 
        InvalidUserNameError = UserName << 8,
 
        InvalidPasswordError = Password << 8,
 
        InvalidRegNameError = Host << 8,
        InvalidIPv4AddressError,
        InvalidIPv6AddressError,
        InvalidCharacterInIPv6Error,
        InvalidIPvFutureError,
        HostMissingEndBracket,
 
        InvalidPortError = Port << 8,
        PortEmptyError,
 
        InvalidPathError = Path << 8,
 
        InvalidQueryError = Query << 8,
 
        InvalidFragmentError = Fragment << 8,
 
        // the following three cases are only possible in combination with
        // presence/absence of the path, authority and scheme. See validityError().
        AuthorityPresentAndPathIsRelative = Authority << 8 | Path << 8 | 0x10000,
        AuthorityAbsentAndPathIsDoubleSlash,
        RelativeUrlPathContainsColonBeforeSlash = Scheme << 8 | Authority << 8 | Path << 8 | 0x10000,
 
        NoError = 0
    };
 
    struct Error {
        QString source;
        qsizetype position;
        ErrorCode code;
    };
 
    QUrlPrivate();
    QUrlPrivate(const QUrlPrivate &copy);
    ~QUrlPrivate();
 
    void parse(const QString &url, QUrl::ParsingMode parsingMode);
    bool isEmpty() const
    { return sectionIsPresent == 0 && port == -1 && path.isEmpty(); }
 
    std::unique_ptr<Error> cloneError() const;
    void clearError();
    void setError(ErrorCode errorCode, const QString &source, qsizetype supplement = -1);
    ErrorCode validityError(QString *source = nullptr, qsizetype *position = nullptr) const;
    bool validateComponent(Section section, const QString &input, qsizetype begin, qsizetype end);
    bool validateComponent(Section section, const QString &input)
    { return validateComponent(section, input, 0, input.size()); }
 
    // no QString scheme() const;
    void appendAuthority(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const;
    void appendUserInfo(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) 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, Section appendingTo) const;
    void appendQuery(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const;
    void appendFragment(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const;
 
    // the "end" parameters are like STL iterators: they point to one past the last valid element
    bool setScheme(const QString &value, qsizetype len, bool doSetError);
    void setAuthority(const QString &auth, qsizetype from, qsizetype end, QUrl::ParsingMode mode);
    void setUserInfo(const QString &userInfo, qsizetype from, qsizetype end);
    void setUserName(const QString &value, qsizetype from, qsizetype end);
    void setPassword(const QString &value, qsizetype from, qsizetype end);
    bool setHost(const QString &value, qsizetype from, qsizetype end, QUrl::ParsingMode mode);
    void setPath(const QString &value, qsizetype from, qsizetype end);
    void setQuery(const QString &value, qsizetype from, qsizetype end);
    void setFragment(const QString &value, qsizetype from, qsizetype 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; }
 
    inline bool isLocalFile() const { return flags & IsLocalFile; }
    QString toLocalFile(QUrl::FormattingOptions options) const;
 
    QString mergePaths(const QString &relativePath) const;
 
    QAtomicInt ref;
    int port;
 
    QString scheme;
    QString userName;
    QString password;
    QString host;
    QString path;
    QString query;
    QString fragment;
 
    std::unique_ptr<Error> error;
 
    // 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;
    uchar flags;
 
    // 32-bit: 2 bytes tail padding available
    // 64-bit: 6 bytes tail padding available
};
 
inline QUrlPrivate::QUrlPrivate()
    : ref(1), port(-1),
      sectionIsPresent(0),
      flags(0)
{
}
 
inline QUrlPrivate::QUrlPrivate(const QUrlPrivate &copy)
    : ref(1), port(copy.port),
      scheme(copy.scheme),
      userName(copy.userName),
      password(copy.password),
      host(copy.host),
      path(copy.path),
      query(copy.query),
      fragment(copy.fragment),
      error(copy.cloneError()),
      sectionIsPresent(copy.sectionIsPresent),
      flags(copy.flags)
{
}
 
inline QUrlPrivate::~QUrlPrivate()
    = default;
 
std::unique_ptr<QUrlPrivate::Error> QUrlPrivate::cloneError() const
{
    return error ? std::make_unique<Error>(*error) : nullptr;
}
 
inline void QUrlPrivate::clearError()
{
    error.reset();
}
 
inline void QUrlPrivate::setError(ErrorCode errorCode, const QString &source, qsizetype supplement)
{
    if (error) {
        // don't overwrite an error set in a previous section during parsing
        return;
    }
    error = std::make_unique<Error>();
    error->code = errorCode;
    error->source = source;
    error->position = supplement;
}
 
// From RFC 3986, Appendix A Collected ABNF for URI
//    URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
//[...]
//    scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
//
//    authority     = [ userinfo "@" ] host [ ":" port ]
//    userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
//    host          = IP-literal / IPv4address / reg-name
//    port          = *DIGIT
//[...]
//    reg-name      = *( unreserved / pct-encoded / sub-delims )
//[..]
//    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
//
//    query         = *( pchar / "/" / "?" )
//
//    fragment      = *( pchar / "/" / "?" )
//
//    pct-encoded   = "%" HEXDIG HEXDIG
//
//    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
//    reserved      = gen-delims / sub-delims
//    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
//    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
//                  / "*" / "+" / "," / ";" / "="
// the path component has a complex ABNF that basically boils down to
// slash-separated segments of "pchar"
 
// The above is the strict definition of the URL components and we mostly
// adhere to it, with few exceptions. QUrl obeys the following behavior:
//  - percent-encoding sequences always use uppercase HEXDIG;
//  - unreserved characters are *always* decoded, no exceptions;
//  - the space character and bytes with the high bit set are controlled by
//    the EncodeSpaces and EncodeUnicode bits;
//  - control characters, the percent sign itself, and bytes with the high
//    bit set that don't form valid UTF-8 sequences are always encoded,
//    except in FullyDecoded mode;
//  - sub-delims are always left alone, except in FullyDecoded mode;
//  - gen-delim change behavior depending on which section of the URL (or
//    the entire URL) we're looking at; see below;
//  - characters not mentioned above, like "<", and ">", are usually
//    decoded in individual sections of the URL, but encoded when the full
//    URL is put together (we can change on subjective definition of
//    "pretty").
//
// The behavior for the delimiters bears some explanation. The spec says in
// section 2.2:
//     URIs that differ in the replacement of a reserved character with its
//     corresponding percent-encoded octet are not equivalent.
// (note: QUrl API mistakenly uses the "reserved" term, so we will refer to
// them here as "delimiters").
//
// For that reason, we cannot encode delimiters found in decoded form and we
// cannot decode the ones found in encoded form if that would change the
// interpretation. Conversely, we *can* perform the transformation if it would
// not change the interpretation. From the last component of a URL to the first,
// here are the gen-delims we can unambiguously transform when the field is
// taken in isolation:
//  - fragment: none, since it's the last
//  - query: "#" is unambiguous
//  - path: "#" and "?" are unambiguous
//  - host: completely special but never ambiguous, see setHost() below.
//  - password: the "#", "?", "/", "[", "]" and "@" characters are unambiguous
//  - username: the "#", "?", "/", "[", "]", "@", and ":" characters are unambiguous
//  - scheme: doesn't accept any delimiter, see setScheme() below.
//
// Internally, QUrl stores each component in the format that corresponds to the
// default mode (PrettyDecoded). It deviates from the "strict" FullyEncoded
// mode in the following way:
//  - spaces are decoded
//  - valid UTF-8 sequences are decoded
//  - gen-delims that can be unambiguously transformed are decoded
//  - characters controlled by DecodeReserved are often decoded, though this behavior
//    can change depending on the subjective definition of "pretty"
//
// Note that the list of gen-delims that we can transform is different for the
// user info (user name + password) and the authority (user info + host +
// port).
 
 
// list the recoding table modifications to be used with the recodeFromUser and
// appendToUser functions, according to the rules above. Spaces and UTF-8
// sequences are handled outside the tables.
 
// the encodedXXX tables are run with the delimiters set to "leave" by default;
// the decodedXXX tables are run with the delimiters set to "decode" by default
// (except for the query, which doesn't use these functions)
 
namespace {
template <typename T> constexpr ushort decode(T x) noexcept { return ushort(x); }
template <typename T> constexpr ushort leave(T x) noexcept { return ushort(0x100 | x); }
template <typename T> constexpr ushort encode(T x) noexcept { return ushort(0x200 | x); }
}
 
static const ushort userNameInIsolation[] = {
    decode(':'), // 0
    decode('@'), // 1
    decode(']'), // 2
    decode('['), // 3
    decode('/'), // 4
    decode('?'), // 5
    decode('#'), // 6
 
    decode('"'), // 7
    decode('<'),
    decode('>'),
    decode('^'),
    decode('\\'),
    decode('|'),
    decode('{'),
    decode('}'),
    0
};
static const ushort * const passwordInIsolation = userNameInIsolation + 1;
static const ushort * const pathInIsolation = userNameInIsolation + 5;
static const ushort * const queryInIsolation = userNameInIsolation + 6;
static const ushort * const fragmentInIsolation = userNameInIsolation + 7;
 
static const ushort userNameInUserInfo[] =  {
    encode(':'), // 0
    decode('@'), // 1
    decode(']'), // 2
    decode('['), // 3
    decode('/'), // 4
    decode('?'), // 5
    decode('#'), // 6
 
    decode('"'), // 7
    decode('<'),
    decode('>'),
    decode('^'),
    decode('\\'),
    decode('|'),
    decode('{'),
    decode('}'),
    0
};
static const ushort * const passwordInUserInfo = userNameInUserInfo + 1;
 
static const ushort userNameInAuthority[] = {
    encode(':'), // 0
    encode('@'), // 1
    encode(']'), // 2
    encode('['), // 3
    decode('/'), // 4
    decode('?'), // 5
    decode('#'), // 6
 
    decode('"'), // 7
    decode('<'),
    decode('>'),
    decode('^'),
    decode('\\'),
    decode('|'),
    decode('{'),
    decode('}'),
    0
};
static const ushort * const passwordInAuthority = userNameInAuthority + 1;
 
static const ushort userNameInUrl[] = {
    encode(':'), // 0
    encode('@'), // 1
    encode(']'), // 2
    encode('['), // 3
    encode('/'), // 4
    encode('?'), // 5
    encode('#'), // 6
 
    // no need to list encode(x) for the other characters
    0
};
static const ushort * const passwordInUrl = userNameInUrl + 1;
static const ushort * const pathInUrl = userNameInUrl + 5;
static const ushort * const queryInUrl = userNameInUrl + 6;
static const ushort * const fragmentInUrl = userNameInUrl + 6;
 
static inline void parseDecodedComponent(QString &data)
{
    data.replace(u'%', "%25"_L1);
}
 
static inline QString
recodeFromUser(const QString &input, const ushort *actions, qsizetype from, qsizetype to)
{
    QString output;
    const QChar *begin = input.constData() + from;
    const QChar *end = input.constData() + to;
    if (qt_urlRecode(output, QStringView{begin, end}, {}, actions))
        return output;
 
    return input.mid(from, to - from);
}
 
// appendXXXX functions: copy from the internal form to the external, user form.
// the internal value is stored in its PrettyDecoded form, so that case is easy.
static inline void appendToUser(QString &appendTo, QStringView value, QUrl::FormattingOptions options,
                                const ushort *actions)
{
    // The stored value is already QUrl::PrettyDecoded, so there's nothing to
    // do if that's what the user asked for (test only
    // ComponentFormattingOptions, ignore FormattingOptions).
    if ((options & 0xFFFF0000) == QUrl::PrettyDecoded ||
            !qt_urlRecode(appendTo, value, options, actions))
        appendTo += value;
 
    // copy nullness, if necessary, because QString::operator+=(QStringView) doesn't
    if (appendTo.isNull() && !value.isNull())
        appendTo.detach();
}
 
inline void QUrlPrivate::appendAuthority(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
{
    if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
        appendUserInfo(appendTo, options, appendingTo);
 
        // add '@' only if we added anything
        if (hasUserName() || (hasPassword() && (options & QUrl::RemovePassword) == 0))
            appendTo += u'@';
    }
    appendHost(appendTo, options);
    if (!(options & QUrl::RemovePort) && port != -1)
        appendTo += u':' + QString::number(port);
}
 
inline void QUrlPrivate::appendUserInfo(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
{
    if (Q_LIKELY(!hasUserInfo()))
        return;
 
    const ushort *userNameActions;
    const ushort *passwordActions;
    if (options & QUrl::EncodeDelimiters) {
        userNameActions = userNameInUrl;
        passwordActions = passwordInUrl;
    } else {
        switch (appendingTo) {
        case UserInfo:
            userNameActions = userNameInUserInfo;
            passwordActions = passwordInUserInfo;
            break;
 
        case Authority:
            userNameActions = userNameInAuthority;
            passwordActions = passwordInAuthority;
            break;
 
        case FullUrl:
            userNameActions = userNameInUrl;
            passwordActions = passwordInUrl;
            break;
 
        default:
            // can't happen
            Q_UNREACHABLE();
            break;
        }
    }
 
    if (!qt_urlRecode(appendTo, userName, options, userNameActions))
        appendTo += userName;
    if (options & QUrl::RemovePassword || !hasPassword()) {
        return;
    } else {
        appendTo += u':';
        if (!qt_urlRecode(appendTo, password, options, passwordActions))
            appendTo += password;
    }
}
 
inline void QUrlPrivate::appendUserName(QString &appendTo, QUrl::FormattingOptions options) const
{
    // only called from QUrl::userName()
    appendToUser(appendTo, userName, options,
                 options & QUrl::EncodeDelimiters ? userNameInUrl : userNameInIsolation);
}
 
inline void QUrlPrivate::appendPassword(QString &appendTo, QUrl::FormattingOptions options) const
{
    // only called from QUrl::password()
    appendToUser(appendTo, password, options,
                 options & QUrl::EncodeDelimiters ? passwordInUrl : passwordInIsolation);
}
 
inline void QUrlPrivate::appendPath(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
{
    QString thePath = path;
    if (options & QUrl::NormalizePathSegments) {
        thePath = qt_normalizePathSegments(path, isLocalFile() ? QDirPrivate::DefaultNormalization : QDirPrivate::RemotePath);
    }
 
    QStringView thePathView(thePath);
    if (options & QUrl::RemoveFilename) {
        const qsizetype slash = path.lastIndexOf(u'/');
        if (slash == -1)
            return;
        thePathView = QStringView{path}.left(slash + 1);
    }
    // check if we need to remove trailing slashes
    if (options & QUrl::StripTrailingSlash) {
        while (thePathView.size() > 1 && thePathView.endsWith(u'/'))
            thePathView.chop(1);
    }
 
    appendToUser(appendTo, thePathView, options,
                 appendingTo == FullUrl || options & QUrl::EncodeDelimiters ? pathInUrl : pathInIsolation);
}
 
inline void QUrlPrivate::appendFragment(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
{
    appendToUser(appendTo, fragment, options,
                 options & QUrl::EncodeDelimiters ? fragmentInUrl :
                 appendingTo == FullUrl ? nullptr : fragmentInIsolation);
}
 
inline void QUrlPrivate::appendQuery(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
{
    appendToUser(appendTo, query, options,
                 appendingTo == FullUrl || options & QUrl::EncodeDelimiters ? queryInUrl : queryInIsolation);
}
 
// setXXX functions
 
inline bool QUrlPrivate::setScheme(const QString &value, qsizetype len, bool doSetError)
{
    // schemes are strictly RFC-compliant:
    //    scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    // we also lowercase the scheme
 
    // schemes in URLs are not allowed to be empty, but they can be in
    // "Relative URIs" which QUrl also supports. QUrl::setScheme does
    // not call us with len == 0, so this can only be from parse()
    scheme.clear();
    if (len == 0)
        return false;
 
    sectionIsPresent |= Scheme;
 
    // validate it:
    qsizetype needsLowercasing = -1;
    const ushort *p = reinterpret_cast<const ushort *>(value.data());
    for (qsizetype i = 0; i < len; ++i) {
        if (isAsciiLower(p[i]))
            continue;
        if (isAsciiUpper(p[i])) {
            needsLowercasing = i;
            continue;
        }
        if (i) {
            if (isAsciiDigit(p[i]))
                continue;
            if (p[i] == '+' || p[i] == '-' || p[i] == '.')
                continue;
        }
 
        // found something else
        // don't call setError needlessly:
        // if we've been called from parse(), it will try to recover
        if (doSetError)
            setError(InvalidSchemeError, value, i);
        return false;
    }
 
    scheme = value.left(len);
 
    if (needsLowercasing != -1) {
        // schemes are ASCII only, so we don't need the full Unicode toLower
        QChar *schemeData = scheme.data(); // force detaching here
        for (qsizetype i = needsLowercasing; i >= 0; --i) {
            ushort c = schemeData[i].unicode();
            if (isAsciiUpper(c))
                schemeData[i] = QChar(c + 0x20);
        }
    }
 
    // did we set to the file protocol?
    if (scheme == fileScheme()
#ifdef Q_OS_WIN
        || scheme == webDavScheme()
#endif
       ) {
        flags |= IsLocalFile;
    } else {
        flags &= ~IsLocalFile;
    }
    return true;
}
 
inline void QUrlPrivate::setAuthority(const QString &auth, qsizetype from, qsizetype end, QUrl::ParsingMode mode)
{
    sectionIsPresent &= ~Authority;
    sectionIsPresent |= Host;
    port = -1;
 
    // we never actually _loop_
    while (from != end) {
        qsizetype userInfoIndex = auth.indexOf(u'@', from);
        if (size_t(userInfoIndex) < size_t(end)) {
            setUserInfo(auth, from, userInfoIndex);
            if (mode == QUrl::StrictMode && !validateComponent(UserInfo, auth, from, userInfoIndex))
                break;
            from = userInfoIndex + 1;
        }
 
        qsizetype colonIndex = auth.lastIndexOf(u':', end - 1);
        if (colonIndex < from)
            colonIndex = -1;
 
        if (size_t(colonIndex) < size_t(end)) {
            if (auth.at(from).unicode() == '[') {
                // check if colonIndex isn't inside the "[...]" part
                qsizetype closingBracket = auth.indexOf(u']', from);
                if (size_t(closingBracket) > size_t(colonIndex))
                    colonIndex = -1;
            }
        }
 
        if (size_t(colonIndex) < size_t(end) - 1) {
            // found a colon with digits after it
            unsigned long x = 0;
            for (qsizetype i = colonIndex + 1; i < end; ++i) {
                ushort c = auth.at(i).unicode();
                if (isAsciiDigit(c)) {
                    x *= 10;
                    x += c - '0';
                } else {
                    x = ulong(-1); // x != ushort(x)
                    break;
                }
            }
            if (x == ushort(x)) {
                port = ushort(x);
            } else {
                setError(InvalidPortError, auth, colonIndex + 1);
                if (mode == QUrl::StrictMode)
                    break;
            }
        }
 
        setHost(auth, from, qMin<size_t>(end, colonIndex), mode);
        if (mode == QUrl::StrictMode && !validateComponent(Host, auth, from, qMin<size_t>(end, colonIndex))) {
            // clear host too
            sectionIsPresent &= ~Authority;
            break;
        }
 
        // success
        return;
    }
    // clear all sections but host
    sectionIsPresent &= ~Authority | Host;
    userName.clear();
    password.clear();
    host.clear();
    port = -1;
}
 
inline void QUrlPrivate::setUserInfo(const QString &userInfo, qsizetype from, qsizetype end)
{
    qsizetype delimIndex = userInfo.indexOf(u':', from);
    setUserName(userInfo, from, qMin<size_t>(delimIndex, end));
 
    if (size_t(delimIndex) >= size_t(end)) {
        password.clear();
        sectionIsPresent &= ~Password;
    } else {
        setPassword(userInfo, delimIndex + 1, end);
    }
}
 
inline void QUrlPrivate::setUserName(const QString &value, qsizetype from, qsizetype end)
{
    sectionIsPresent |= UserName;
    userName = recodeFromUser(value, userNameInIsolation, from, end);
}
 
inline void QUrlPrivate::setPassword(const QString &value, qsizetype from, qsizetype end)
{
    sectionIsPresent |= Password;
    password = recodeFromUser(value, passwordInIsolation, from, end);
}
 
inline void QUrlPrivate::setPath(const QString &value, qsizetype from, qsizetype end)
{
    // sectionIsPresent |= Path; // not used, save some cycles
    path = recodeFromUser(value, pathInIsolation, from, end);
}
 
inline void QUrlPrivate::setFragment(const QString &value, qsizetype from, qsizetype end)
{
    sectionIsPresent |= Fragment;
    fragment = recodeFromUser(value, fragmentInIsolation, from, end);
}
 
inline void QUrlPrivate::setQuery(const QString &value, qsizetype from, qsizetype iend)
{
    sectionIsPresent |= Query;
    query = recodeFromUser(value, queryInIsolation, from, iend);
}
 
// Host handling
// The RFC says the host is:
//    host          = IP-literal / IPv4address / reg-name
//    IP-literal    = "[" ( IPv6address / IPvFuture  ) "]"
//    IPvFuture     = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
//  [a strict definition of IPv6Address and IPv4Address]
//     reg-name      = *( unreserved / pct-encoded / sub-delims )
//
// We deviate from the standard in all but IPvFuture. For IPvFuture we accept
// and store only exactly what the RFC says we should. No percent-encoding is
// permitted in this field, so Unicode characters and space aren't either.
//
// For IPv4 addresses, we accept broken addresses like inet_aton does (that is,
// less than three dots). However, we correct the address to the proper form
// and store the corrected address. After correction, we comply to the RFC and
// it's exclusively composed of unreserved characters.
//
// For IPv6 addresses, we accept addresses including trailing (embedded) IPv4
// addresses, the so-called v4-compat and v4-mapped addresses. We also store
// those addresses like that in the hostname field, which violates the spec.
// IPv6 hosts are stored with the square brackets in the QString. It also
// requires no transformation in any way.
//
// As for registered names, it's the other way around: we accept only valid
// hostnames as specified by STD 3 and IDNA. That means everything we accept is
// valid in the RFC definition above, but there are many valid reg-names
// according to the RFC that we do not accept in the name of security. Since we
// do accept IDNA, reg-names are subject to ACE encoding and decoding, which is
// specified by the DecodeUnicode flag. The hostname is stored in its Unicode form.
 
inline void QUrlPrivate::appendHost(QString &appendTo, QUrl::FormattingOptions options) const
{
    if (host.isEmpty())
        return;
    if (host.at(0).unicode() == '[') {
        // IPv6 addresses might contain a zone-id which needs to be recoded
        if (options != 0)
            if (qt_urlRecode(appendTo, host, options, nullptr))
                return;
        appendTo += host;
    } else {
        // this is either an IPv4Address or a reg-name
        // if it is a reg-name, it is already stored in Unicode form
        if (options & QUrl::EncodeUnicode && !(options & 0x4000000))
            appendTo += qt_ACE_do(host, ToAceOnly, AllowLeadingDot, {});
        else
            appendTo += host;
    }
}
 
// the whole IPvFuture is passed and parsed here, including brackets;
// returns null if the parsing was successful, or the QChar of the first failure
static const QChar *parseIpFuture(QString &host, const QChar *begin, const QChar *end, QUrl::ParsingMode mode)
{
    //    IPvFuture     = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
    static const char acceptable[] =
            "!$&'()*+,;=" // sub-delims
            ":"           // ":"
            "-._~";       // unreserved
 
    // the brackets and the "v" have been checked
    const QChar *const origBegin = begin;
    if (begin[3].unicode() != '.')
        return &begin[3];
    if (isHexDigit(begin[2].unicode())) {
        // this is so unlikely that we'll just go down the slow path
        // decode the whole string, skipping the "[vH." and "]" which we already know to be there
        host += QStringView(begin, 4);
 
        // uppercase the version, if necessary
        if (begin[2].unicode() >= 'a')
            host[host.size() - 2] = QChar{begin[2].unicode() - 0x20};
 
        begin += 4;
        --end;
 
        QString decoded;
        if (mode == QUrl::TolerantMode && qt_urlRecode(decoded, QStringView{begin, end}, QUrl::FullyDecoded, nullptr)) {
            begin = decoded.constBegin();
            end = decoded.constEnd();
        }
 
        for ( ; begin != end; ++begin) {
            if (isAsciiLetterOrNumber(begin->unicode()))
                host += *begin;
            else if (begin->unicode() < 0x80 && strchr(acceptable, begin->unicode()) != nullptr)
                host += *begin;
            else
                return decoded.isEmpty() ? begin : &origBegin[2];
        }
        host += u']';
        return nullptr;
    }
    return &origBegin[2];
}
 
// ONLY the IPv6 address is parsed here, WITHOUT the brackets
static const QChar *parseIp6(QString &host, const QChar *begin, const QChar *end, QUrl::ParsingMode mode)
{
    QStringView decoded(begin, end);
    QString decodedBuffer;
    if (mode == QUrl::TolerantMode) {
        // this struct is kept in automatic storage because it's only 4 bytes
        const ushort decodeColon[] = { decode(':'), 0 };
        if (qt_urlRecode(decodedBuffer, decoded, QUrl::ComponentFormattingOption::PrettyDecoded, decodeColon))
            decoded = decodedBuffer;
    }
 
    const QStringView zoneIdIdentifier(u"%25");
    QIPAddressUtils::IPv6Address address;
    QStringView zoneId;
 
    qsizetype zoneIdPosition = decoded.indexOf(zoneIdIdentifier);
    if ((zoneIdPosition != -1) && (decoded.lastIndexOf(zoneIdIdentifier) == zoneIdPosition)) {
        zoneId = decoded.mid(zoneIdPosition + zoneIdIdentifier.size());
        decoded.truncate(zoneIdPosition);
 
        // was there anything after the zone ID separator?
        if (zoneId.isEmpty())
            return end;
    }
 
    // did the address become empty after removing the zone ID?
    // (it might have always been empty)
    if (decoded.isEmpty())
        return end;
 
    const QChar *ret = QIPAddressUtils::parseIp6(address, decoded.constBegin(), decoded.constEnd());
    if (ret)
        return begin + (ret - decoded.constBegin());
 
    host.reserve(host.size() + (end - begin) + 2);  // +2 for the brackets
    host += u'[';
    QIPAddressUtils::toString(host, address);
 
    if (!zoneId.isEmpty()) {
        host += zoneIdIdentifier;
        host += zoneId;
    }
    host += u']';
    return nullptr;
}
 
inline bool
QUrlPrivate::setHost(const QString &value, qsizetype from, qsizetype iend, QUrl::ParsingMode mode)
{
    const QChar *begin = value.constData() + from;
    const QChar *end = value.constData() + iend;
 
    const qsizetype len = end - begin;
    host.clear();
    sectionIsPresent |= Host;
    if (len == 0)
        return true;
 
    if (begin[0].unicode() == '[') {
        // IPv6Address or IPvFuture
        // smallest IPv6 address is      "[::]"   (len = 4)
        // smallest IPvFuture address is "[v7.X]" (len = 6)
        if (end[-1].unicode() != ']') {
            setError(HostMissingEndBracket, value);
            return false;
        }
 
        if (len > 5 && begin[1].unicode() == 'v') {
            const QChar *c = parseIpFuture(host, begin, end, mode);
            if (c)
                setError(InvalidIPvFutureError, value, c - value.constData());
            return !c;
        } else if (begin[1].unicode() == 'v') {
            setError(InvalidIPvFutureError, value, from);
        }
 
        const QChar *c = parseIp6(host, begin + 1, end - 1, mode);
        if (!c)
            return true;
 
        if (c == end - 1)
            setError(InvalidIPv6AddressError, value, from);
        else
            setError(InvalidCharacterInIPv6Error, value, c - value.constData());
        return false;
    }
 
    // check if it's an IPv4 address
    QIPAddressUtils::IPv4Address ip4;
    if (QIPAddressUtils::parseIp4(ip4, begin, end)) {
        // yes, it was
        QIPAddressUtils::toString(host, ip4);
        return true;
    }
 
    // This is probably a reg-name.
    // But it can also be an encoded string that, when decoded becomes one
    // of the types above.
    //
    // Two types of encoding are possible:
    //  percent encoding (e.g., "%31%30%2E%30%2E%30%2E%31" -> "10.0.0.1")
    //  Unicode encoding (some non-ASCII characters case-fold to digits
    //                    when nameprepping is done)
    //
    // The qt_ACE_do function below does IDNA normalization and the STD3 check.
    // That means a Unicode string may become an IPv4 address, but it cannot
    // produce a '[' or a '%'.
 
    // check for percent-encoding first
    QString s;
    if (mode == QUrl::TolerantMode && qt_urlRecode(s, QStringView{begin, end}, { }, nullptr)) {
        // something was decoded
        // anything encoded left?
        qsizetype pos = s.indexOf(QChar(0x25)); // '%'
        if (pos != -1) {
            setError(InvalidRegNameError, s, pos);
            return false;
        }
 
        // recurse
        return setHost(s, 0, s.size(), QUrl::StrictMode);
    }
 
    s = qt_ACE_do(value.mid(from, iend - from), NormalizeAce, ForbidLeadingDot, {});
    if (s.isEmpty()) {
        setError(InvalidRegNameError, value);
        return false;
    }
 
    // check IPv4 again
    if (QIPAddressUtils::parseIp4(ip4, s.constBegin(), s.constEnd())) {
        QIPAddressUtils::toString(host, ip4);
    } else {
        host = s;
    }
    return true;
}
 
inline void QUrlPrivate::parse(const QString &url, QUrl::ParsingMode parsingMode)
{
    //   URI-reference = URI / relative-ref
    //   URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
    //   relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
    //   hier-part     = "//" authority path-abempty
    //                 / other path types
    //   relative-part = "//" authority path-abempty
    //                 /  other path types here
 
    sectionIsPresent = 0;
    flags = 0;
    clearError();
 
    // find the important delimiters
    qsizetype colon = -1;
    qsizetype question = -1;
    qsizetype hash = -1;
    const qsizetype len = url.size();
    const QChar *const begin = url.constData();
    const ushort *const data = reinterpret_cast<const ushort *>(begin);
 
    for (qsizetype i = 0; i < len; ++i) {
        size_t uc = data[i];
        if (uc == '#' && hash == -1) {
            hash = i;
 
            // nothing more to be found
            break;
        }
 
        if (question == -1) {
            if (uc == ':' && colon == -1)
                colon = i;
            else if (uc == '?')
                question = i;
        }
    }
 
    // check if we have a scheme
    qsizetype hierStart;
    if (colon != -1 && setScheme(url, colon, /* don't set error */ false)) {
        hierStart = colon + 1;
    } else {
        // recover from a failed scheme: it might not have been a scheme at all
        scheme.clear();
        sectionIsPresent = 0;
        hierStart = 0;
    }
 
    qsizetype pathStart;
    qsizetype hierEnd = qMin<size_t>(qMin<size_t>(question, hash), len);
    if (hierEnd - hierStart >= 2 && data[hierStart] == '/' && data[hierStart + 1] == '/') {
        // we have an authority, it ends at the first slash after these
        qsizetype authorityEnd = hierEnd;
        for (qsizetype i = hierStart + 2; i < authorityEnd ; ++i) {
            if (data[i] == '/') {
                authorityEnd = i;
                break;
            }
        }
 
        setAuthority(url, hierStart + 2, authorityEnd, parsingMode);
 
        // even if we failed to set the authority properly, let's try to recover
        pathStart = authorityEnd;
        setPath(url, pathStart, hierEnd);
    } else {
        userName.clear();
        password.clear();
        host.clear();
        port = -1;
        pathStart = hierStart;
 
        if (hierStart < hierEnd)
            setPath(url, hierStart, hierEnd);
        else
            path.clear();
    }
 
    if (size_t(question) < size_t(hash))
        setQuery(url, question + 1, qMin<size_t>(hash, len));
 
    if (hash != -1)
        setFragment(url, hash + 1, len);
 
    if (error || parsingMode == QUrl::TolerantMode)
        return;
 
    // The parsing so far was partially tolerant of errors, except for the
    // scheme parser (which is always strict) and the authority (which was
    // executed in strict mode).
    // If we haven't found any errors so far, continue the strict-mode parsing
    // from the path component onwards.
 
    if (!validateComponent(Path, url, pathStart, hierEnd))
        return;
    if (size_t(question) < size_t(hash) && !validateComponent(Query, url, question + 1, qMin<size_t>(hash, len)))
        return;
    if (hash != -1)
        validateComponent(Fragment, url, hash + 1, len);
}
 
QString QUrlPrivate::toLocalFile(QUrl::FormattingOptions options) const
{
    QString tmp;
    QString ourPath;
    appendPath(ourPath, options, QUrlPrivate::Path);
 
    // magic for shared drive on windows
    if (!host.isEmpty()) {
        tmp = "//"_L1 + host;
#ifdef Q_OS_WIN // QTBUG-42346, WebDAV is visible as local file on Windows only.
        if (scheme == webDavScheme())
            tmp += webDavSslTag();
#endif
        if (!ourPath.isEmpty() && !ourPath.startsWith(u'/'))
            tmp += u'/';
        tmp += ourPath;
    } else {
        tmp = ourPath;
#ifdef Q_OS_WIN
        // magic for drives on windows
        if (ourPath.length() > 2 && ourPath.at(0) == u'/' && ourPath.at(2) == u':')
            tmp.remove(0, 1);
#endif
    }
    return tmp;
}
 
/*
    From http://www.ietf.org/rfc/rfc3986.txt, 5.2.3: Merge paths
 
    Returns a merge of the current path with the relative path passed
    as argument.
 
    Note: \a relativePath is relative (does not start with '/').
*/
inline QString QUrlPrivate::mergePaths(const QString &relativePath) const
{
    // If the base URI has a defined authority component and an empty
    // path, then return a string consisting of "/" concatenated with
    // the reference's path; otherwise,
    if (!host.isEmpty() && path.isEmpty())
        return u'/' + relativePath;
 
    // Return a string consisting of the reference's path component
    // appended to all but the last segment of the base URI's path
    // (i.e., excluding any characters after the right-most "/" in the
    // base URI path, or excluding the entire base URI path if it does
    // not contain any "/" characters).
    QString newPath;
    if (!path.contains(u'/'))
        newPath = relativePath;
    else
        newPath = QStringView{path}.left(path.lastIndexOf(u'/') + 1) + relativePath;
 
    return newPath;
}
 
/*
    From http://www.ietf.org/rfc/rfc3986.txt, 5.2.4: Remove dot segments
 
    Removes unnecessary ../ and ./ from the path. Used for normalizing
    the URL.
*/
static void removeDotsFromPath(QString *path)
{
    // The input buffer is initialized with the now-appended path
    // components and the output buffer is initialized to the empty
    // string.
    QChar *out = path->data();
    const QChar *in = out;
    const QChar *end = out + path->size();
 
    // If the input buffer consists only of
    // "." or "..", then remove that from the input
    // buffer;
    if (path->size() == 1 && in[0].unicode() == '.')
        ++in;
    else if (path->size() == 2 && in[0].unicode() == '.' && in[1].unicode() == '.')
        in += 2;
    // While the input buffer is not empty, loop:
    while (in < end) {
 
        // otherwise, if the input buffer begins with a prefix of "../" or "./",
        // then remove that prefix from the input buffer;
        if (path->size() >= 2 && in[0].unicode() == '.' && in[1].unicode() == '/')
            in += 2;
        else if (path->size() >= 3 && in[0].unicode() == '.'
                 && in[1].unicode() == '.' && in[2].unicode() == '/')
            in += 3;
 
        // otherwise, if the input buffer begins with a prefix of
        // "/./" or "/.", where "." is a complete path segment,
        // then replace that prefix with "/" in the input buffer;
        if (in <= end - 3 && in[0].unicode() == '/' && in[1].unicode() == '.'
                && in[2].unicode() == '/') {
            in += 2;
            continue;
        } else if (in == end - 2 && in[0].unicode() == '/' && in[1].unicode() == '.') {
            *out++ = u'/';
            in += 2;
            break;
        }
 
        // otherwise, if the input buffer begins with a prefix
        // of "/../" or "/..", where ".." is a complete path
        // segment, then replace that prefix with "/" in the
        // input buffer and remove the last //segment and its
        // preceding "/" (if any) from the output buffer;
        if (in <= end - 4 && in[0].unicode() == '/' && in[1].unicode() == '.'
                && in[2].unicode() == '.' && in[3].unicode() == '/') {
            while (out > path->constData() && (--out)->unicode() != '/')
                ;
            if (out == path->constData() && out->unicode() != '/')
                ++in;
            in += 3;
            continue;
        } else if (in == end - 3 && in[0].unicode() == '/' && in[1].unicode() == '.'
                   && in[2].unicode() == '.') {
            while (out > path->constData() && (--out)->unicode() != '/')
                ;
            if (out->unicode() == '/')
                ++out;
            in += 3;
            break;
        }
 
        // otherwise move the first path segment in
        // the input buffer to the end of the output
        // buffer, including the initial "/" character
        // (if any) and any subsequent characters up
        // to, but not including, the next "/"
        // character or the end of the input buffer.
        *out++ = *in++;
        while (in < end && in->unicode() != '/')
            *out++ = *in++;
    }
    path->truncate(out - path->constData());
}
 
inline QUrlPrivate::ErrorCode QUrlPrivate::validityError(QString *source, qsizetype *position) const
{
    Q_ASSERT(!source == !position);
    if (error) {
        if (source) {
            *source = error->source;
            *position = error->position;
        }
        return error->code;
    }
 
    // There are three more cases of invalid URLs that QUrl recognizes and they
    // are only possible with constructed URLs (setXXX methods), not with
    // parsing. Therefore, they are tested here.
    //
    // Two cases are a non-empty path that doesn't start with a slash and:
    //  - with an authority
    //  - without an authority, without scheme but the path with a colon before
    //    the first slash
    // The third case is an empty authority and a non-empty path that starts
    // with "//".
    // Those cases are considered invalid because toString() would produce a URL
    // that wouldn't be parsed back to the same QUrl.
 
    if (path.isEmpty())
        return NoError;
    if (path.at(0) == u'/') {
        if (hasAuthority() || path.size() == 1 || path.at(1) != u'/')
            return NoError;
        if (source) {
            *source = path;
            *position = 0;
        }
        return AuthorityAbsentAndPathIsDoubleSlash;
    }
 
    if (sectionIsPresent & QUrlPrivate::Host) {
        if (source) {
            *source = path;
            *position = 0;
        }
        return AuthorityPresentAndPathIsRelative;
    }
    if (sectionIsPresent & QUrlPrivate::Scheme)
        return NoError;
 
    // check for a path of "text:text/"
    for (qsizetype i = 0; i < path.size(); ++i) {
        ushort c = path.at(i).unicode();
        if (c == '/') {
            // found the slash before the colon
            return NoError;
        }
        if (c == ':') {
            // found the colon before the slash, it's invalid
            if (source) {
                *source = path;
                *position = i;
            }
            return RelativeUrlPathContainsColonBeforeSlash;
        }
    }
    return NoError;
}
 
bool QUrlPrivate::validateComponent(QUrlPrivate::Section section, const QString &input,
                                    qsizetype begin, qsizetype end)
{
    // What we need to look out for, that the regular parser tolerates:
    //  - percent signs not followed by two hex digits
    //  - forbidden characters, which should always appear encoded
    //    '"' / '<' / '>' / '\' / '^' / '`' / '{' / '|' / '}' / BKSP
    //    control characters
    //  - delimiters not allowed in certain positions
    //    . scheme: parser is already strict
    //    . user info: gen-delims except ":" disallowed ("/" / "?" / "#" / "[" / "]" / "@")
    //    . host: parser is stricter than the standard
    //    . port: parser is stricter than the standard
    //    . path: all delimiters allowed
    //    . fragment: all delimiters allowed
    //    . query: all delimiters allowed
    static const char forbidden[] = "\"<>\\^`{|}\x7F";
    static const char forbiddenUserInfo[] = ":/?#[]@";
 
    Q_ASSERT(section != Authority && section != Hierarchy && section != FullUrl);
 
    const ushort *const data = reinterpret_cast<const ushort *>(input.constData());
    for (size_t i = size_t(begin); i < size_t(end); ++i) {
        uint uc = data[i];
        if (uc >= 0x80)
            continue;
 
        bool error = false;
        if ((uc == '%' && (size_t(end) < i + 2 || !isHex(data[i + 1]) || !isHex(data[i + 2])))
                || uc <= 0x20 || strchr(forbidden, uc)) {
            // found an error
            error = true;
        } else if (section & UserInfo) {
            if (section == UserInfo && strchr(forbiddenUserInfo + 1, uc))
                error = true;
            else if (section != UserInfo && strchr(forbiddenUserInfo, uc))
                error = true;
        }
 
        if (!error)
            continue;
 
        ErrorCode errorCode = ErrorCode(int(section) << 8);
        if (section == UserInfo) {
            // is it the user name or the password?
            errorCode = InvalidUserNameError;
            for (size_t j = size_t(begin); j < i; ++j)
                if (data[j] == ':') {
                    errorCode = InvalidPasswordError;
                    break;
                }
        }
 
        setError(errorCode, input, i);
        return false;
    }
 
    // no errors
    return true;
}
 
#if 0
inline void QUrlPrivate::validate() const
{
    QUrlPrivate *that = (QUrlPrivate *)this;
    that->encodedOriginal = that->toEncoded(); // may detach
    parse(ParseOnly);
 
    QURL_SETFLAG(that->stateFlags, Validated);
 
    if (!isValid)
        return;
 
    QString auth = authority(); // causes the non-encoded forms to be valid
 
    // authority() calls canonicalHost() which sets this
    if (!isHostValid)
        return;
 
    if (scheme == "mailto"_L1) {
        if (!host.isEmpty() || port != -1 || !userName.isEmpty() || !password.isEmpty()) {
            that->isValid = false;
            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "expected empty host, username,"
                                                           "port and password"),
                                      0, 0);
        }
    } else if (scheme == ftpScheme() || scheme == httpScheme()) {
        if (host.isEmpty() && !(path.isEmpty() && encodedPath.isEmpty())) {
            that->isValid = false;
            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "the host is empty, but not the path"),
                                      0, 0);
        }
    }
}
#endif
 
QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d(nullptr)
{
    setUrl(url, parsingMode);
}
 
QUrl::QUrl() : d(nullptr)
{
}
 
QUrl::QUrl(const QUrl &other) noexcept : d(other.d)
{
    if (d)
        d->ref.ref();
}
 
QUrl::~QUrl()
{
    if (d && !d->ref.deref())
        delete d;
}
 
bool QUrl::isValid() const
{
    if (isEmpty()) {
        // also catches d == nullptr
        return false;
    }
    return d->validityError() == QUrlPrivate::NoError;
}
 
bool QUrl::isEmpty() const
{
    if (!d) return true;
    return d->isEmpty();
}
 
void QUrl::clear()
{
    if (d && !d->ref.deref())
        delete d;
    d = nullptr;
}
 
void QUrl::setUrl(const QString &url, ParsingMode parsingMode)
{
    if (parsingMode == DecodedMode) {
        qWarning("QUrl: QUrl::DecodedMode is not permitted when parsing a full URL");
    } else {
        detach();
        d->parse(url, parsingMode);
    }
}
 
void QUrl::setScheme(const QString &scheme)
{
    detach();
    d->clearError();
    if (scheme.isEmpty()) {
        // schemes are not allowed to be empty
        d->sectionIsPresent &= ~QUrlPrivate::Scheme;
        d->flags &= ~QUrlPrivate::IsLocalFile;
        d->scheme.clear();
    } else {
        d->setScheme(scheme, scheme.size(), /* do set error */ true);
    }
}
 
QString QUrl::scheme() const
{
    if (!d) return QString();
 
    return d->scheme;
}
 
void QUrl::setAuthority(const QString &authority, ParsingMode mode)
{
    detach();
    d->clearError();
 
    if (mode == DecodedMode) {
        qWarning("QUrl::setAuthority(): QUrl::DecodedMode is not permitted in this function");
        return;
    }
 
    d->setAuthority(authority, 0, authority.size(), mode);
    if (authority.isNull()) {
        // QUrlPrivate::setAuthority cleared almost everything
        // but it leaves the Host bit set
        d->sectionIsPresent &= ~QUrlPrivate::Authority;
    }
}
 
QString QUrl::authority(ComponentFormattingOptions options) const
{
    QString result;
    if (!d)
        return result;
 
    if (options == QUrl::FullyDecoded) {
        qWarning("QUrl::authority(): QUrl::FullyDecoded is not permitted in this function");
        return result;
    }
 
    d->appendAuthority(result, options, QUrlPrivate::Authority);
    return result;
}
 
void QUrl::setUserInfo(const QString &userInfo, ParsingMode mode)
{
    detach();
    d->clearError();
    QString trimmed = userInfo.trimmed();
    if (mode == DecodedMode) {
        qWarning("QUrl::setUserInfo(): QUrl::DecodedMode is not permitted in this function");
        return;
    }
 
    d->setUserInfo(trimmed, 0, trimmed.size());
    if (userInfo.isNull()) {
        // QUrlPrivate::setUserInfo cleared almost everything
        // but it leaves the UserName bit set
        d->sectionIsPresent &= ~QUrlPrivate::UserInfo;
    } else if (mode == StrictMode && !d->validateComponent(QUrlPrivate::UserInfo, userInfo)) {
        d->sectionIsPresent &= ~QUrlPrivate::UserInfo;
        d->userName.clear();
        d->password.clear();
    }
}
 
QString QUrl::userInfo(ComponentFormattingOptions options) const
{
    QString result;
    if (!d)
        return result;
 
    if (options == QUrl::FullyDecoded) {
        qWarning("QUrl::userInfo(): QUrl::FullyDecoded is not permitted in this function");
        return result;
    }
 
    d->appendUserInfo(result, options, QUrlPrivate::UserInfo);
    return result;
}
 
void QUrl::setUserName(const QString &userName, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = userName;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    d->setUserName(data, 0, data.size());
    if (userName.isNull())
        d->sectionIsPresent &= ~QUrlPrivate::UserName;
    else if (mode == StrictMode && !d->validateComponent(QUrlPrivate::UserName, userName))
        d->userName.clear();
}
 
QString QUrl::userName(ComponentFormattingOptions options) const
{
    QString result;
    if (d)
        d->appendUserName(result, options);
    return result;
}
 
void QUrl::setPassword(const QString &password, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = password;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    d->setPassword(data, 0, data.size());
    if (password.isNull())
        d->sectionIsPresent &= ~QUrlPrivate::Password;
    else if (mode == StrictMode && !d->validateComponent(QUrlPrivate::Password, password))
        d->password.clear();
}
 
QString QUrl::password(ComponentFormattingOptions options) const
{
    QString result;
    if (d)
        d->appendPassword(result, options);
    return result;
}
 
void QUrl::setHost(const QString &host, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = host;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    if (d->setHost(data, 0, data.size(), mode)) {
        if (host.isNull())
            d->sectionIsPresent &= ~QUrlPrivate::Host;
    } else if (!data.startsWith(u'[')) {
        // setHost failed, it might be IPv6 or IPvFuture in need of bracketing
        Q_ASSERT(d->error);
 
        data.prepend(u'[');
        data.append(u']');
        if (!d->setHost(data, 0, data.size(), mode)) {
            // failed again
            if (data.contains(u':')) {
                // source data contains ':', so it's an IPv6 error
                d->error->code = QUrlPrivate::InvalidIPv6AddressError;
            }
        } else {
            // succeeded
            d->clearError();
        }
    }
}
 
QString QUrl::host(ComponentFormattingOptions options) const
{
    QString result;
    if (d) {
        d->appendHost(result, options);
        if (result.startsWith(u'['))
            result = result.mid(1, result.size() - 2);
    }
    return result;
}
 
void QUrl::setPort(int port)
{
    detach();
    d->clearError();
 
    if (port < -1 || port > 65535) {
        d->setError(QUrlPrivate::InvalidPortError, QString::number(port), 0);
        port = -1;
    }
 
    d->port = port;
    if (port != -1)
        d->sectionIsPresent |= QUrlPrivate::Host;
}
 
int QUrl::port(int defaultPort) const
{
    if (!d) return defaultPort;
    return d->port == -1 ? defaultPort : d->port;
}
 
void QUrl::setPath(const QString &path, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = path;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    d->setPath(data, 0, data.size());
 
    // optimized out, since there is no path delimiter
//    if (path.isNull())
//        d->sectionIsPresent &= ~QUrlPrivate::Path;
//    else
    if (mode == StrictMode && !d->validateComponent(QUrlPrivate::Path, path))
        d->path.clear();
}
 
QString QUrl::path(ComponentFormattingOptions options) const
{
    QString result;
    if (d)
        d->appendPath(result, options, QUrlPrivate::Path);
    return result;
}
 
QString QUrl::fileName(ComponentFormattingOptions options) const
{
    const QString ourPath = path(options);
    const qsizetype slash = ourPath.lastIndexOf(u'/');
    if (slash == -1)
        return ourPath;
    return ourPath.mid(slash + 1);
}
 
bool QUrl::hasQuery() const
{
    if (!d) return false;
    return d->hasQuery();
}
 
void QUrl::setQuery(const QString &query, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = query;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    d->setQuery(data, 0, data.size());
    if (query.isNull())
        d->sectionIsPresent &= ~QUrlPrivate::Query;
    else if (mode == StrictMode && !d->validateComponent(QUrlPrivate::Query, query))
        d->query.clear();
}
 
void QUrl::setQuery(const QUrlQuery &query)
{
    detach();
    d->clearError();
 
    // we know the data is in the right format
    d->query = query.toString();
    if (query.isEmpty())
        d->sectionIsPresent &= ~QUrlPrivate::Query;
    else
        d->sectionIsPresent |= QUrlPrivate::Query;
}
 
QString QUrl::query(ComponentFormattingOptions options) const
{
    QString result;
    if (d) {
        d->appendQuery(result, options, QUrlPrivate::Query);
        if (d->hasQuery() && result.isNull())
            result.detach();
    }
    return result;
}
 
void QUrl::setFragment(const QString &fragment, ParsingMode mode)
{
    detach();
    d->clearError();
 
    QString data = fragment;
    if (mode == DecodedMode) {
        parseDecodedComponent(data);
        mode = TolerantMode;
    }
 
    d->setFragment(data, 0, data.size());
    if (fragment.isNull())
        d->sectionIsPresent &= ~QUrlPrivate::Fragment;
    else if (mode == StrictMode && !d->validateComponent(QUrlPrivate::Fragment, fragment))
        d->fragment.clear();
}
 
QString QUrl::fragment(ComponentFormattingOptions options) const
{
    QString result;
    if (d) {
        d->appendFragment(result, options, QUrlPrivate::Fragment);
        if (d->hasFragment() && result.isNull())
            result.detach();
    }
    return result;
}
 
bool QUrl::hasFragment() const
{
    if (!d) return false;
    return d->hasFragment();
}
 
QUrl QUrl::resolved(const QUrl &relative) const
{
    if (!d) return relative;
    if (!relative.d) return *this;
 
    QUrl t;
    if (!relative.d->scheme.isEmpty()) {
        t = relative;
        t.detach();
    } else {
        if (relative.d->hasAuthority()) {
            t = relative;
            t.detach();
        } else {
            t.d = new QUrlPrivate;
 
            // copy the authority
            t.d->userName = d->userName;
            t.d->password = d->password;
            t.d->host = d->host;
            t.d->port = d->port;
            t.d->sectionIsPresent = d->sectionIsPresent & QUrlPrivate::Authority;
 
            if (relative.d->path.isEmpty()) {
                t.d->path = d->path;
                if (relative.d->hasQuery()) {
                    t.d->query = relative.d->query;
                    t.d->sectionIsPresent |= QUrlPrivate::Query;
                } else if (d->hasQuery()) {
                    t.d->query = d->query;
                    t.d->sectionIsPresent |= QUrlPrivate::Query;
                }
            } else {
                t.d->path = relative.d->path.startsWith(u'/')
                            ? relative.d->path
                            : d->mergePaths(relative.d->path);
                if (relative.d->hasQuery()) {
                    t.d->query = relative.d->query;
                    t.d->sectionIsPresent |= QUrlPrivate::Query;
                }
            }
        }
        t.d->scheme = d->scheme;
        if (d->hasScheme())
            t.d->sectionIsPresent |= QUrlPrivate::Scheme;
        else
            t.d->sectionIsPresent &= ~QUrlPrivate::Scheme;
        t.d->flags |= d->flags & QUrlPrivate::IsLocalFile;
    }
    t.d->fragment = relative.d->fragment;
    if (relative.d->hasFragment())
        t.d->sectionIsPresent |= QUrlPrivate::Fragment;
    else
        t.d->sectionIsPresent &= ~QUrlPrivate::Fragment;
 
    removeDotsFromPath(&t.d->path);
 
#if defined(QURL_DEBUG)
    qDebug("QUrl(\"%ls\").resolved(\"%ls\") = \"%ls\"",
           qUtf16Printable(url()),
           qUtf16Printable(relative.url()),
           qUtf16Printable(t.url()));
#endif
    return t;
}
 
bool QUrl::isRelative() const
{
    if (!d) return true;
    return !d->hasScheme();
}
 
QString QUrl::url(FormattingOptions options) const
{
    return toString(options);
}
 
QString QUrl::toString(FormattingOptions options) const
{
    QString url;
    if (!isValid()) {
        // also catches isEmpty()
        return url;
    }
    if ((options & QUrl::FullyDecoded) == QUrl::FullyDecoded) {
        qWarning("QUrl: QUrl::FullyDecoded is not permitted when reconstructing the full URL");
        options &= ~QUrl::FullyDecoded;
        //options |= QUrl::PrettyDecoded; // no-op, value is 0
    }
 
    // return just the path if:
    //  - QUrl::PreferLocalFile is passed
    //  - QUrl::RemovePath isn't passed (rather stupid if the user did...)
    //  - there's no query or fragment to return
    //    that is, either they aren't present, or we're removing them
    //  - it's a local file
    if (options.testFlag(QUrl::PreferLocalFile) && !options.testFlag(QUrl::RemovePath)
            && (!d->hasQuery() || options.testFlag(QUrl::RemoveQuery))
            && (!d->hasFragment() || options.testFlag(QUrl::RemoveFragment))
            && isLocalFile()) {
        url = d->toLocalFile(options | QUrl::FullyDecoded);
        return url;
    }
 
    // for the full URL, we consider that the reserved characters are prettier if encoded
    if (options & DecodeReserved)
        options &= ~EncodeReserved;
    else
        options |= EncodeReserved;
 
    if (!(options & QUrl::RemoveScheme) && d->hasScheme())
        url += d->scheme + u':';
 
    bool pathIsAbsolute = d->path.startsWith(u'/');
    if (!((options & QUrl::RemoveAuthority) == QUrl::RemoveAuthority) && d->hasAuthority()) {
        url += "//"_L1;
        d->appendAuthority(url, options, QUrlPrivate::FullUrl);
    } else if (isLocalFile() && pathIsAbsolute) {
        // Comply with the XDG file URI spec, which requires triple slashes.
        url += "//"_L1;
    }
 
    if (!(options & QUrl::RemovePath))
        d->appendPath(url, options, QUrlPrivate::FullUrl);
 
    if (!(options & QUrl::RemoveQuery) && d->hasQuery()) {
        url += u'?';
        d->appendQuery(url, options, QUrlPrivate::FullUrl);
    }
    if (!(options & QUrl::RemoveFragment) && d->hasFragment()) {
        url += u'#';
        d->appendFragment(url, options, QUrlPrivate::FullUrl);
    }
 
    return url;
}
 
QString QUrl::toDisplayString(FormattingOptions options) const
{
    return toString(options | RemovePassword);
}
 
QUrl QUrl::adjusted(QUrl::FormattingOptions options) const
{
    if (!isValid()) {
        // also catches isEmpty()
        return QUrl();
    }
    QUrl that = *this;
    if (options & RemoveScheme)
        that.setScheme(QString());
    if ((options & RemoveAuthority) == RemoveAuthority) {
        that.setAuthority(QString());
    } else {
        if ((options & RemoveUserInfo) == RemoveUserInfo)
            that.setUserInfo(QString());
        else if (options & RemovePassword)
            that.setPassword(QString());
        if (options & RemovePort)
            that.setPort(-1);
    }
    if (options & RemoveQuery)
        that.setQuery(QString());
    if (options & RemoveFragment)
        that.setFragment(QString());
    if (options & RemovePath) {
        that.setPath(QString());
    } else if (options & (StripTrailingSlash | RemoveFilename | NormalizePathSegments)) {
        that.detach();
        QString path;
        d->appendPath(path, options | FullyEncoded, QUrlPrivate::Path);
        that.d->setPath(path, 0, path.size());
    }
    return that;
}
 
QByteArray QUrl::toEncoded(FormattingOptions options) const
{
    options &= ~(FullyDecoded | FullyEncoded);
    return toString(options | FullyEncoded).toLatin1();
}
 
QUrl QUrl::fromEncoded(QByteArrayView input, ParsingMode mode)
{
    return QUrl(QString::fromUtf8(input), mode);
}
 
QString QUrl::fromPercentEncoding(const QByteArray &input)
{
    QByteArray ba = QByteArray::fromPercentEncoding(input);
    return QString::fromUtf8(ba, ba.size());
}
 
QByteArray QUrl::toPercentEncoding(const QString &input, const QByteArray &exclude, const QByteArray &include)
{
    return input.toUtf8().toPercentEncoding(exclude, include);
}
 
QString QUrl::fromAce(const QByteArray &domain, QUrl::AceProcessingOptions options)
{
    return qt_ACE_do(QString::fromLatin1(domain), NormalizeAce,
                     ForbidLeadingDot /*FIXME: make configurable*/, options);
}
 
QByteArray QUrl::toAce(const QString &domain, AceProcessingOptions options)
{
    return qt_ACE_do(domain, ToAceOnly, ForbidLeadingDot /*FIXME: make configurable*/, options)
            .toLatin1();
}
 
bool QUrl::operator <(const QUrl &url) const
{
    if (!d || !url.d) {
        bool thisIsEmpty = !d || d->isEmpty();
        bool thatIsEmpty = !url.d || url.d->isEmpty();
 
        // sort an empty URL first
        return thisIsEmpty && !thatIsEmpty;
    }
 
    int cmp;
    cmp = d->scheme.compare(url.d->scheme);
    if (cmp != 0)
        return cmp < 0;
 
    cmp = d->userName.compare(url.d->userName);
    if (cmp != 0)
        return cmp < 0;
 
    cmp = d->password.compare(url.d->password);
    if (cmp != 0)
        return cmp < 0;
 
    cmp = d->host.compare(url.d->host);
    if (cmp != 0)
        return cmp < 0;
 
    if (d->port != url.d->port)
        return d->port < url.d->port;
 
    cmp = d->path.compare(url.d->path);
    if (cmp != 0)
        return cmp < 0;
 
    if (d->hasQuery() != url.d->hasQuery())
        return url.d->hasQuery();
 
    cmp = d->query.compare(url.d->query);
    if (cmp != 0)
        return cmp < 0;
 
    if (d->hasFragment() != url.d->hasFragment())
        return url.d->hasFragment();
 
    cmp = d->fragment.compare(url.d->fragment);
    return cmp < 0;
}
 
bool QUrl::operator ==(const QUrl &url) const
{
    if (!d && !url.d)
        return true;
    if (!d)
        return url.d->isEmpty();
    if (!url.d)
        return d->isEmpty();
 
    // First, compare which sections are present, since it speeds up the
    // processing considerably. We just have to ignore the host-is-present flag
    // for local files (the "file" protocol), due to the requirements of the
    // XDG file URI specification.
    int mask = QUrlPrivate::FullUrl;
    if (isLocalFile())
        mask &= ~QUrlPrivate::Host;
    return (d->sectionIsPresent & mask) == (url.d->sectionIsPresent & mask) &&
            d->scheme == url.d->scheme &&
            d->userName == url.d->userName &&
            d->password == url.d->password &&
            d->host == url.d->host &&
            d->port == url.d->port &&
            d->path == url.d->path &&
            d->query == url.d->query &&
            d->fragment == url.d->fragment;
}
 
bool QUrl::matches(const QUrl &url, FormattingOptions options) const
{
    if (!d && !url.d)
        return true;
    if (!d)
        return url.d->isEmpty();
    if (!url.d)
        return d->isEmpty();
 
    // First, compare which sections are present, since it speeds up the
    // processing considerably. We just have to ignore the host-is-present flag
    // for local files (the "file" protocol), due to the requirements of the
    // XDG file URI specification.
    int mask = QUrlPrivate::FullUrl;
    if (isLocalFile())
        mask &= ~QUrlPrivate::Host;
 
    if (options.testFlag(QUrl::RemoveScheme))
        mask &= ~QUrlPrivate::Scheme;
    else if (d->scheme != url.d->scheme)
        return false;
 
    if (options.testFlag(QUrl::RemovePassword))
        mask &= ~QUrlPrivate::Password;
    else if (d->password != url.d->password)
        return false;
 
    if (options.testFlag(QUrl::RemoveUserInfo))
        mask &= ~QUrlPrivate::UserName;
    else if (d->userName != url.d->userName)
        return false;
 
    if (options.testFlag(QUrl::RemovePort))
        mask &= ~QUrlPrivate::Port;
    else if (d->port != url.d->port)
        return false;
 
    if (options.testFlag(QUrl::RemoveAuthority))
        mask &= ~QUrlPrivate::Host;
    else if (d->host != url.d->host)
        return false;
 
    if (options.testFlag(QUrl::RemoveQuery))
        mask &= ~QUrlPrivate::Query;
    else if (d->query != url.d->query)
        return false;
 
    if (options.testFlag(QUrl::RemoveFragment))
        mask &= ~QUrlPrivate::Fragment;
    else if (d->fragment != url.d->fragment)
        return false;
 
    if ((d->sectionIsPresent & mask) != (url.d->sectionIsPresent & mask))
        return false;
 
    if (options.testFlag(QUrl::RemovePath))
        return true;
 
    // Compare paths, after applying path-related options
    QString path1;
    d->appendPath(path1, options, QUrlPrivate::Path);
    QString path2;
    url.d->appendPath(path2, options, QUrlPrivate::Path);
    return path1 == path2;
}
 
bool QUrl::operator !=(const QUrl &url) const
{
    return !(*this == url);
}
 
QUrl &QUrl::operator =(const QUrl &url) noexcept
{
    if (!d) {
        if (url.d) {
            url.d->ref.ref();
            d = url.d;
        }
    } else {
        if (url.d)
            qAtomicAssign(d, url.d);
        else
            clear();
    }
    return *this;
}
 
QUrl &QUrl::operator =(const QString &url)
{
    if (url.isEmpty()) {
        clear();
    } else {
        detach();
        d->parse(url, TolerantMode);
    }
    return *this;
}
 
void QUrl::detach()
{
    if (!d)
        d = new QUrlPrivate;
    else
        qAtomicDetach(d);
}
 
bool QUrl::isDetached() const
{
    return !d || d->ref.loadRelaxed() == 1;
}
 
static QString fromNativeSeparators(const QString &pathName)
{
#if defined(Q_OS_WIN)
    QString result(pathName);
    const QChar nativeSeparator = u'\\';
    auto i = result.indexOf(nativeSeparator);
    if (i != -1) {
        QChar * const data = result.data();
        const auto length = result.length();
        for (; i < length; ++i) {
            if (data[i] == nativeSeparator)
                data[i] = u'/';
        }
    }
    return result;
#else
    return pathName;
#endif
}
 
QUrl QUrl::fromLocalFile(const QString &localFile)
{
    QUrl url;
    if (localFile.isEmpty())
        return url;
    QString scheme = fileScheme();
    QString deslashified = fromNativeSeparators(localFile);
 
    // magic for drives on windows
    if (deslashified.size() > 1 && deslashified.at(1) == u':' && deslashified.at(0) != u'/') {
        deslashified.prepend(u'/');
    } else if (deslashified.startsWith("//"_L1)) {
        // magic for shared drive on windows
        qsizetype indexOfPath = deslashified.indexOf(u'/', 2);
        QStringView hostSpec = QStringView{deslashified}.mid(2, indexOfPath - 2);
        // Check for Windows-specific WebDAV specification: "//host@SSL/path".
        if (hostSpec.endsWith(webDavSslTag(), Qt::CaseInsensitive)) {
            hostSpec.truncate(hostSpec.size() - 4);
            scheme = webDavScheme();
        }
 
        // hosts can't be IPv6 addresses without [], so we can use QUrlPrivate::setHost
        url.detach();
        if (!url.d->setHost(hostSpec.toString(), 0, hostSpec.size(), StrictMode)) {
            if (url.d->error->code != QUrlPrivate::InvalidRegNameError)
                return url;
 
            // Path hostname is not a valid URL host, so set it entirely in the path
            // (by leaving deslashified unchanged)
        } else if (indexOfPath > 2) {
            deslashified = deslashified.right(deslashified.size() - indexOfPath);
        } else {
            deslashified.clear();
        }
    }
 
    url.setScheme(scheme);
    url.setPath(deslashified, DecodedMode);
    return url;
}
 
QString QUrl::toLocalFile() const
{
    // the call to isLocalFile() also ensures that we're parsed
    if (!isLocalFile())
        return QString();
 
    return d->toLocalFile(QUrl::FullyDecoded);
}
 
bool QUrl::isLocalFile() const
{
    return d && d->isLocalFile();
}
 
bool QUrl::isParentOf(const QUrl &childUrl) const
{
    QString childPath = childUrl.path();
 
    if (!d)
        return ((childUrl.scheme().isEmpty())
            && (childUrl.authority().isEmpty())
            && childPath.size() > 0 && childPath.at(0) == u'/');
 
    QString ourPath = path();
 
    return ((childUrl.scheme().isEmpty() || d->scheme == childUrl.scheme())
            && (childUrl.authority().isEmpty() || authority() == childUrl.authority())
            &&  childPath.startsWith(ourPath)
            && ((ourPath.endsWith(u'/') && childPath.size() > ourPath.size())
                || (!ourPath.endsWith(u'/') && childPath.size() > ourPath.size()
                    && childPath.at(ourPath.size()) == u'/')));
}
 
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &out, const QUrl &url)
{
    QByteArray u;
    if (url.isValid())
        u = url.toEncoded();
    out << u;
    return out;
}
 
QDataStream &operator>>(QDataStream &in, QUrl &url)
{
    QByteArray u;
    in >> u;
    url.setUrl(QString::fromLatin1(u));
    return in;
}
#endif // QT_NO_DATASTREAM
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug d, const QUrl &url)
{
    QDebugStateSaver saver(d);
    d.nospace() << "QUrl(" << url.toDisplayString() << ')';
    return d;
}
#endif
 
static QString errorMessage(QUrlPrivate::ErrorCode errorCode, const QString &errorSource, qsizetype errorPosition)
{
    QChar c = size_t(errorPosition) < size_t(errorSource.size()) ?
                errorSource.at(errorPosition) : QChar(QChar::Null);
 
    switch (errorCode) {
    case QUrlPrivate::NoError:
        Q_UNREACHABLE_RETURN(QString()); // QUrl::errorString should have treated this condition
 
    case QUrlPrivate::InvalidSchemeError: {
        auto msg = "Invalid scheme (character '%1' not permitted)"_L1;
        return msg.arg(c);
    }
 
    case QUrlPrivate::InvalidUserNameError:
        return "Invalid user name (character '%1' not permitted)"_L1
                .arg(c);
 
    case QUrlPrivate::InvalidPasswordError:
        return "Invalid password (character '%1' not permitted)"_L1
                .arg(c);
 
    case QUrlPrivate::InvalidRegNameError:
        if (errorPosition >= 0)
            return "Invalid hostname (character '%1' not permitted)"_L1
                    .arg(c);
        else
            return QStringLiteral("Invalid hostname (contains invalid characters)");
    case QUrlPrivate::InvalidIPv4AddressError:
        return QString(); // doesn't happen yet
    case QUrlPrivate::InvalidIPv6AddressError:
        return QStringLiteral("Invalid IPv6 address");
    case QUrlPrivate::InvalidCharacterInIPv6Error:
        return "Invalid IPv6 address (character '%1' not permitted)"_L1.arg(c);
    case QUrlPrivate::InvalidIPvFutureError:
        return "Invalid IPvFuture address (character '%1' not permitted)"_L1.arg(c);
    case QUrlPrivate::HostMissingEndBracket:
        return QStringLiteral("Expected ']' to match '[' in hostname");
 
    case QUrlPrivate::InvalidPortError:
        return QStringLiteral("Invalid port or port number out of range");
    case QUrlPrivate::PortEmptyError:
        return QStringLiteral("Port field was empty");
 
    case QUrlPrivate::InvalidPathError:
        return "Invalid path (character '%1' not permitted)"_L1
                .arg(c);
 
    case QUrlPrivate::InvalidQueryError:
        return "Invalid query (character '%1' not permitted)"_L1
                .arg(c);
 
    case QUrlPrivate::InvalidFragmentError:
        return "Invalid fragment (character '%1' not permitted)"_L1
                .arg(c);
 
    case QUrlPrivate::AuthorityPresentAndPathIsRelative:
        return QStringLiteral("Path component is relative and authority is present");
    case QUrlPrivate::AuthorityAbsentAndPathIsDoubleSlash:
        return QStringLiteral("Path component starts with '//' and authority is absent");
    case QUrlPrivate::RelativeUrlPathContainsColonBeforeSlash:
        return QStringLiteral("Relative URL's path component contains ':' before any '/'");
    }
 
    Q_UNREACHABLE_RETURN(QString());
}
 
static inline void appendComponentIfPresent(QString &msg, bool present, const char *componentName,
                                            const QString &component)
{
    if (present)
        msg += QLatin1StringView(componentName) % u'"' % component % "\","_L1;
}
 
QString QUrl::errorString() const
{
    QString msg;
    if (!d)
        return msg;
 
    QString errorSource;
    qsizetype errorPosition = 0;
    QUrlPrivate::ErrorCode errorCode = d->validityError(&errorSource, &errorPosition);
    if (errorCode == QUrlPrivate::NoError)
        return msg;
 
    msg += errorMessage(errorCode, errorSource, errorPosition);
    msg += "; source was \""_L1;
    msg += errorSource;
    msg += "\";"_L1;
    appendComponentIfPresent(msg, d->sectionIsPresent & QUrlPrivate::Scheme,
                             " scheme = ", d->scheme);
    appendComponentIfPresent(msg, d->sectionIsPresent & QUrlPrivate::UserInfo,
                             " userinfo = ", userInfo());
    appendComponentIfPresent(msg, d->sectionIsPresent & QUrlPrivate::Host,
                             " host = ", d->host);
    appendComponentIfPresent(msg, d->port != -1,
                             " port = ", QString::number(d->port));
    appendComponentIfPresent(msg, !d->path.isEmpty(),
                             " path = ", d->path);
    appendComponentIfPresent(msg, d->sectionIsPresent & QUrlPrivate::Query,
                             " query = ", d->query);
    appendComponentIfPresent(msg, d->sectionIsPresent & QUrlPrivate::Fragment,
                             " fragment = ", d->fragment);
    if (msg.endsWith(u','))
        msg.chop(1);
    return msg;
}
 
QStringList QUrl::toStringList(const QList<QUrl> &urls, FormattingOptions options)
{
    QStringList lst;
    lst.reserve(urls.size());
    for (const QUrl &url : urls)
        lst.append(url.toString(options));
    return lst;
 
}
 
QList<QUrl> QUrl::fromStringList(const QStringList &urls, ParsingMode mode)
{
    QList<QUrl> lst;
    lst.reserve(urls.size());
    for (const QString &str : urls)
        lst.append(QUrl(str, mode));
    return lst;
}
 
size_t qHash(const QUrl &url, size_t seed) noexcept
{
    if (!url.d)
        return qHash(-1, seed); // the hash of an unset port (-1)
 
    return qHash(url.d->scheme) ^
            qHash(url.d->userName) ^
            qHash(url.d->password) ^
            qHash(url.d->host) ^
            qHash(url.d->port, seed) ^
            qHash(url.d->path) ^
            qHash(url.d->query) ^
            qHash(url.d->fragment);
}
 
static QUrl adjustFtpPath(QUrl url)
{
    if (url.scheme() == ftpScheme()) {
        QString path = url.path(QUrl::PrettyDecoded);
        if (path.startsWith("//"_L1))
            url.setPath("/%2F"_L1 + QStringView{path}.mid(2), QUrl::TolerantMode);
    }
    return url;
}
 
static bool isIp6(const QString &text)
{
    QIPAddressUtils::IPv6Address address;
    return !text.isEmpty() && QIPAddressUtils::parseIp6(address, text.begin(), text.end()) == nullptr;
}
 
QUrl QUrl::fromUserInput(const QString &userInput, const QString &workingDirectory,
                         UserInputResolutionOptions options)
{
    QString trimmedString = userInput.trimmed();
 
    if (trimmedString.isEmpty())
        return QUrl();
 
    // Check for IPv6 addresses, since a path starting with ":" is absolute (a resource)
    // and IPv6 addresses can start with "c:" too
    if (isIp6(trimmedString)) {
        QUrl url;
        url.setHost(trimmedString);
        url.setScheme(QStringLiteral("http"));
        return url;
    }
 
    const QUrl url = QUrl(trimmedString, QUrl::TolerantMode);
 
    // Check for a relative path
    if (!workingDirectory.isEmpty()) {
        const QFileInfo fileInfo(QDir(workingDirectory), userInput);
        if (fileInfo.exists())
            return QUrl::fromLocalFile(fileInfo.absoluteFilePath());
 
        // Check both QUrl::isRelative (to detect full URLs) and QDir::isAbsolutePath (since on Windows drive letters can be interpreted as schemes)
        if ((options & AssumeLocalFile) && url.isRelative() && !QDir::isAbsolutePath(userInput))
            return QUrl::fromLocalFile(fileInfo.absoluteFilePath());
    }
 
    // Check first for files, since on Windows drive letters can be interpreted as schemes
    if (QDir::isAbsolutePath(trimmedString))
        return QUrl::fromLocalFile(trimmedString);
 
    QUrl urlPrepended = QUrl("http://"_L1 + trimmedString, QUrl::TolerantMode);
 
    // Check the most common case of a valid url with a scheme
    // We check if the port would be valid by adding the scheme to handle the case host:port
    // where the host would be interpreted as the scheme
    if (url.isValid()
        && !url.scheme().isEmpty()
        && urlPrepended.port() == -1)
        return adjustFtpPath(url);
 
    // Else, try the prepended one and adjust the scheme from the host name
    if (urlPrepended.isValid() && (!urlPrepended.host().isEmpty() || !urlPrepended.path().isEmpty())) {
        qsizetype dotIndex = trimmedString.indexOf(u'.');
        const QStringView hostscheme = QStringView{trimmedString}.left(dotIndex);
        if (hostscheme.compare(ftpScheme(), Qt::CaseInsensitive) == 0)
            urlPrepended.setScheme(ftpScheme());
        return adjustFtpPath(urlPrepended);
    }
 
    return QUrl();
}
 
QT_END_NAMESPACE