1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtCore module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 /*!

    43     \class QUrl

    44 

    45     \brief The QUrl class provides a convenient interface for working

    46     with URLs.

    47 

    48     \reentrant

    49     \ingroup io

    50     \ingroup network

    51     \ingroup shared

    52 

    53 

    54     It can parse and construct URLs in both encoded and unencoded

    55     form. QUrl also has support for internationalized domain names

    56     (IDNs).

    57 

    58     The most common way to use QUrl is to initialize it via the

    59     constructor by passing a QString. Otherwise, setUrl() and

    60     setEncodedUrl() can also be used.

    61 

    62     URLs can be represented in two forms: encoded or unencoded. The

    63     unencoded representation is suitable for showing to users, but

    64     the encoded representation is typically what you would send to

    65     a web server. For example, the unencoded URL

    66     "http://b\uuml\c{}hler.example.com" would be sent to the server as

    67     "http://xn--bhler-kva.example.com/List%20of%20applicants.xml".

    68 

    69     A URL can also be constructed piece by piece by calling

    70     setScheme(), setUserName(), setPassword(), setHost(), setPort(),

    71     setPath(), setEncodedQuery() and setFragment(). Some convenience

    72     functions are also available: setAuthority() sets the user name,

    73     password, host and port. setUserInfo() sets the user name and

    74     password at once.

    75 

    76     Call isValid() to check if the URL is valid. This can be done at

    77     any point during the constructing of a URL.

    78 

    79     Constructing a query is particularly convenient through the use

    80     of setQueryItems(), addQueryItem() and removeQueryItem(). Use

    81     setQueryDelimiters() to customize the delimiters used for

    82     generating the query string.

    83 

    84     For the convenience of generating encoded URL strings or query

    85     strings, there are two static functions called

    86     fromPercentEncoding() and toPercentEncoding() which deal with

    87     percent encoding and decoding of QStrings.

    88 

    89     Calling isRelative() will tell whether or not the URL is

    90     relative. A relative URL can be resolved by passing it as argument

    91     to resolved(), which returns an absolute URL. isParentOf() is used

    92     for determining whether one URL is a parent of another.

    93 

    94     fromLocalFile() constructs a QUrl by parsing a local

    95     file path. toLocalFile() converts a URL to a local file path.

    96 

    97     The human readable representation of the URL is fetched with

    98     toString(). This representation is appropriate for displaying a

    99     URL to a user in unencoded form. The encoded form however, as

   100     returned by toEncoded(), is for internal use, passing to web

   101     servers, mail clients and so on.

   102 

   103     QUrl conforms to the URI specification from

   104     \l{RFC 3986} (Uniform Resource Identifier: Generic Syntax), and includes

   105     scheme extensions from \l{RFC 1738} (Uniform Resource Locators). Case

   106     folding rules in QUrl conform to \l{RFC 3491} (Nameprep: A Stringprep

   107     Profile for Internationalized Domain Names (IDN)).

   108 

   109     \sa QUrlInfo

   110 */

   111 

   112 /*!

   113     \enum QUrl::ParsingMode

   114 

   115     The parsing mode controls the way QUrl parses strings.

   116 

   117     \value TolerantMode QUrl will try to correct some common errors in URLs.

   118                         This mode is useful when processing URLs entered by

   119                         users.

   120 

   121     \value StrictMode Only valid URLs are accepted. This mode is useful for

   122                       general URL validation.

   123 

   124     In TolerantMode, the parser corrects the following invalid input:

   125 

   126     \list

   127 

   128     \o Spaces and "%20": If an encoded URL contains a space, this will be

   129     replaced with "%20". If a decoded URL contains "%20", this will be

   130     replaced with a single space before the URL is parsed.

   131 

   132     \o Single "%" characters: Any occurrences of a percent character "%" not

   133     followed by exactly two hexadecimal characters (e.g., "13% coverage.html")

   134     will be replaced by "%25".

   135 

   136     \o Reserved and unreserved characters: An encoded URL should only

   137     contain a few characters as literals; all other characters should

   138     be percent-encoded. In TolerantMode, these characters will be

   139     automatically percent-encoded where they are not allowed:

   140             space / double-quote / "<" / ">" / "[" / "\" /

   141             "]" / "^" / "`" / "{" / "|" / "}"

   142 

   143     \endlist

   144 */

   145 

   146 /*!

   147     \enum QUrl::FormattingOption

   148 

   149     The formatting options define how the URL is formatted when written out

   150     as text.

   151 

   152     \value None The format of the URL is unchanged.

   153     \value RemoveScheme  The scheme is removed from the URL.

   154     \value RemovePassword  Any password in the URL is removed.

   155     \value RemoveUserInfo  Any user information in the URL is removed.

   156     \value RemovePort      Any specified port is removed from the URL.

   157     \value RemoveAuthority

   158     \value RemovePath   The URL's path is removed, leaving only the scheme,

   159                         host address, and port (if present).

   160     \value RemoveQuery  The query part of the URL (following a '?' character)

   161                         is removed.

   162     \value RemoveFragment

   163     \value StripTrailingSlash  The trailing slash is removed if one is present.

   164 

   165     Note that the case folding rules in \l{RFC 3491}{Nameprep}, which QUrl

   166     conforms to, require host names to always be converted to lower case,

   167     regardless of the Qt::FormattingOptions used.

   168 */

   169 

   170 #include "qplatformdefs.h"

   171 #include "qurl.h"

   172 #include "private/qunicodetables_p.h"

   173 #include "qatomic.h"

   174 #include "qbytearray.h"

   175 #include "qdir.h"

   176 #include "qfile.h"

   177 #include "qlist.h"

   178 #ifndef QT_NO_REGEXP

   179 #include "qregexp.h"

   180 #endif

   181 #include "qstring.h"

   182 #include "qstringlist.h"

   183 #include "qstack.h"

   184 #include "qvarlengtharray.h"

   185 #include "qdebug.h"

   186 #if defined QT3_SUPPORT

   187 #include "qfileinfo.h"

   188 #endif

   189 

   190 #if defined(Q_OS_WINCE_WM)

   191 #pragma optimize("g", off)

   192 #endif

   193 

   194 QT_BEGIN_NAMESPACE

   195 

   196 extern void q_normalizePercentEncoding(QByteArray *ba, const char *exclude);

   197 extern void q_toPercentEncoding(QByteArray *ba, const char *exclude, const char *include = 0);

   198 extern void q_fromPercentEncoding(QByteArray *ba);

   199 

   200 static QByteArray toPercentEncodingHelper(const QString &s, const char *exclude, const char *include = 0)

   201 {

   202     if (s.isNull())

   203         return QByteArray();    // null

   204     QByteArray ba = s.toUtf8();

   205     q_toPercentEncoding(&ba, exclude, include);

   206     return ba;

   207 }

   208 

   209 static QString fromPercentEncodingHelper(const QByteArray &ba)

   210 {

   211     if (ba.isNull())

   212         return QString();       // null

   213     QByteArray copy = ba;

   214     q_fromPercentEncoding(&copy);

   215     return QString::fromUtf8(copy.constData(), copy.length());

   216 }

   217 

   218 static QString fromPercentEncodingMutable(QByteArray *ba)

   219 {

   220     if (ba->isNull())

   221         return QString();       // null

   222     q_fromPercentEncoding(ba);

   223     return QString::fromUtf8(ba->constData(), ba->length());

   224 }

   225 

   226 // ### Qt 5: Consider accepting empty strings as valid. See task 144227.

   227 

   228 //#define QURL_DEBUG

   229 

   230 // implemented in qvsnprintf.cpp

   231 Q_CORE_EXPORT int qsnprintf(char *str, size_t n, const char *fmt, ...);

   232 

   233 // needed by the punycode encoder/decoder

   234 #define Q_MAXINT ((uint)((uint)(-1)>>1))

   235 static const uint base = 36;

   236 static const uint tmin = 1;

   237 static const uint tmax = 26;

   238 static const uint skew = 38;

   239 static const uint damp = 700;

   240 static const uint initial_bias = 72;

   241 static const uint initial_n = 128;

   242 

   243 #define QURL_SETFLAG(a, b) { (a) |= (b); }

   244 #define QURL_UNSETFLAG(a, b) { (a) &= ~(b); }

   245 #define QURL_HASFLAG(a, b) (((a) & (b)) == (b))

   246 

   247 struct QUrlErrorInfo {

   248     inline QUrlErrorInfo() : _source(0), _message(0), _expected(0), _found(0)

   249     { }

   250 

   251     const char *_source;

   252     const char *_message;

   253     char _expected;

   254     char _found;

   255 

   256     inline void setParams(const char *source, const char *message, char expected, char found)

   257     {

   258         _source = source;

   259         _message = message;

   260         _expected = expected;

   261         _found = found;

   262     }

   263 };

   264 

   265 struct QUrlParseData

   266 {

   267     const char *scheme;

   268     int schemeLength;

   269     

   270     const char *userInfo;

   271     int userInfoDelimIndex;

   272     int userInfoLength;

   273     

   274     const char *host;

   275     int hostLength;

   276     int port;

   277 

   278     const char *path;

   279     int pathLength;

   280     const char *query;

   281     int queryLength;

   282     const char *fragment;

   283     int fragmentLength;

   284 };

   285 

   286 

   287 class QUrlPrivate

   288 {

   289 public:

   290     QUrlPrivate();

   291     QUrlPrivate(const QUrlPrivate &other);

   292 

   293     bool setUrl(const QString &url);

   294 

   295     QString canonicalHost() const;

   296     void ensureEncodedParts() const;

   297     QString authority(QUrl::FormattingOptions options = QUrl::None) const;

   298     void setAuthority(const QString &auth);

   299     void setUserInfo(const QString &userInfo);

   300     QString userInfo(QUrl::FormattingOptions options = QUrl::None) const;

   301     void setEncodedAuthority(const QByteArray &authority);

   302     void setEncodedUserInfo(const QUrlParseData *parseData);

   303 

   304     QByteArray mergePaths(const QByteArray &relativePath) const;

   305 

   306     void queryItem(int pos, int *value, int *end);

   307 

   308     enum ParseOptions {

   309         ParseAndSet,

   310         ParseOnly

   311     };

   312 

   313     void validate() const;

   314     void parse(ParseOptions parseOptions = ParseAndSet) const;

   315     void clear();

   316 

   317     QByteArray toEncoded(QUrl::FormattingOptions options = QUrl::None) const;

   318 

   319     QAtomicInt ref;

   320 

   321     QString scheme;

   322     QString userName;

   323     QString password;

   324     QString host;

   325     QString path;

   326     QByteArray query;

   327     QString fragment;

   328 

   329     QByteArray encodedOriginal;

   330     QByteArray encodedUserName;

   331     QByteArray encodedPassword;

   332     QByteArray encodedPath;

   333     QByteArray encodedFragment;

   334 

   335     int port;

   336     QUrl::ParsingMode parsingMode;

   337 

   338     bool hasQuery;

   339     bool hasFragment;

   340     bool isValid;

   341 

   342     char valueDelimiter;

   343     char pairDelimiter;

   344 

   345     enum State {

   346         Parsed = 0x1,

   347         Validated = 0x2,

   348         Normalized = 0x4,

   349         HostCanonicalized = 0x8

   350     };

   351     int stateFlags;

   352 

   353     QByteArray encodedNormalized;

   354     const QByteArray & normalized();

   355 

   356     mutable QUrlErrorInfo errorInfo;

   357     QString createErrorString();

   358 };

   359 

   360 

   361 static bool QT_FASTCALL _HEXDIG(const char **ptr)

   362 {

   363     char ch = **ptr;

   364     if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {

   365         ++(*ptr);

   366         return true;

   367     }

   368 

   369     return false;

   370 }

   371 

   372 // pct-encoded = "%" HEXDIG HEXDIG

   373 static bool QT_FASTCALL _pctEncoded(const char **ptr)

   374 {

   375     const char *ptrBackup = *ptr;

   376 

   377     if (**ptr != '%')

   378         return false;

   379     ++(*ptr);

   380     

   381     if (!_HEXDIG(ptr)) {

   382         *ptr = ptrBackup;

   383         return false;

   384     }

   385     if (!_HEXDIG(ptr)) {

   386         *ptr = ptrBackup;

   387         return false;

   388     }

   389 

   390     return true;

   391 }

   392 

   393 #if 0

   394 // gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"

   395 static bool QT_FASTCALL _genDelims(const char **ptr, char *c)

   396 {

   397     char ch = **ptr;

   398     switch (ch) {

   399     case ':': case '/': case '?': case '#':

   400     case '[': case ']': case '@':

   401         *c = ch;

   402         ++(*ptr);

   403         return true;

   404     default:

   405         return false;

   406     }

   407 }

   408 #endif

   409 

   410 // sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"

   411 //             / "*" / "+" / "," / ";" / "="

   412 static bool QT_FASTCALL _subDelims(const char **ptr)

   413 {

   414     char ch = **ptr;

   415     switch (ch) {

   416     case '!': case '$': case '&': case '\'':

   417     case '(': case ')': case '*': case '+':

   418     case ',': case ';': case '=':

   419         ++(*ptr);

   420         return true;

   421     default:

   422         return false;

   423     }

   424 }

   425 

   426 // unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"

   427 static bool QT_FASTCALL _unreserved(const char **ptr)

   428 {

   429     char ch = **ptr;

   430     if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')

   431         || (ch >= '0' && ch <= '9')

   432         || ch == '-' || ch == '.' || ch == '_' || ch == '~') {

   433         ++(*ptr);

   434         return true;

   435     } 

   436     return false;

   437 }

   438 

   439 // scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

   440 static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)

   441 {

   442     bool first = true;

   443 

   444     parseData->scheme = *ptr;

   445     for (;;) {

   446         char ch = **ptr;

   447         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {

   448             ;

   449         } else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {

   450             ;

   451         } else {

   452             break;

   453         }

   454 

   455         ++(*ptr);

   456         first = false;

   457     }

   458 

   459     if (**ptr != ':') {

   460         *ptr = parseData->scheme;

   461     } else {

   462         parseData->schemeLength = *ptr - parseData->scheme;

   463         ++(*ptr); // skip ':'

   464     }

   465 }

   466 

   467 // IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )

   468 static bool QT_FASTCALL _IPvFuture(const char **ptr)

   469 {

   470     if (**ptr != 'v')

   471         return false;

   472 

   473     const char *ptrBackup = *ptr;

   474     ++(*ptr);

   475     

   476     if (!_HEXDIG(ptr)) {

   477         *ptr = ptrBackup;

   478         return false;

   479     }

   480 

   481     while (_HEXDIG(ptr))

   482         ;

   483 

   484     if (**ptr != '.') {

   485         *ptr = ptrBackup;

   486         return false;

   487     }

   488     ++(*ptr);

   489 

   490     if (!_unreserved(ptr) && !_subDelims(ptr) && *((*ptr)++) != ':') {

   491         *ptr = ptrBackup;

   492         return false;

   493     }

   494 

   495 

   496     while (_unreserved(ptr) || _subDelims(ptr) || *((*ptr)++) == ':')

   497         ;

   498 

   499     return true;

   500 }

   501 

   502 // h16         = 1*4HEXDIG

   503 //             ; 16 bits of address represented in hexadecimal

   504 static bool QT_FASTCALL _h16(const char **ptr)

   505 {

   506     int i = 0;

   507     for (; i < 4; ++i) {

   508         if (!_HEXDIG(ptr))

   509             break;

   510     }

   511     return (i != 0);

   512 }

   513 

   514 // dec-octet   = DIGIT                 ; 0-9

   515 //             / %x31-39 DIGIT         ; 10-99

   516 //             / "1" 2DIGIT            ; 100-199

   517 //             / "2" %x30-34 DIGIT     ; 200-249

   518 //             / "25" %x30-35          ; 250-255

   519 static bool QT_FASTCALL _decOctet(const char **ptr)

   520 {

   521     const char *ptrBackup = *ptr;

   522     char c1 = **ptr;

   523 

   524     if (c1 < '0' || c1 > '9') 

   525         return false;

   526 

   527     ++(*ptr);

   528 

   529     if (c1 == '0')

   530         return true;

   531 

   532     char c2 = **ptr;

   533 

   534     if (c2 < '0' || c2 > '9')

   535         return true;

   536 

   537     ++(*ptr);

   538 

   539     char c3 = **ptr;

   540     if (c3 < '0' || c3 > '9')

   541         return true;

   542 

   543     // If there is a three digit number larger than 255, reject the

   544     // whole token.

   545     if (c1 >= '2' && c2 >= '5' && c3 > '5') {

   546         *ptr = ptrBackup;

   547         return false;

   548     }

   549 

   550     ++(*ptr);

   551 

   552     return true;

   553 }

   554 

   555 // IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet

   556 static bool QT_FASTCALL _IPv4Address(const char **ptr)

   557 {

   558     const char *ptrBackup = *ptr;

   559 

   560     if (!_decOctet(ptr)) {

   561         *ptr = ptrBackup;

   562         return false;

   563     }

   564 

   565     for (int i = 0; i < 3; ++i) {

   566         char ch = *((*ptr)++);

   567         if (ch != '.') {

   568             *ptr = ptrBackup;

   569             return false;

   570         }

   571 

   572         if (!_decOctet(ptr)) {

   573             *ptr = ptrBackup;

   574             return false;

   575         }

   576     }

   577 

   578     return true;

   579 }

   580 

   581 // ls32        = ( h16 ":" h16 ) / IPv4address

   582 //             ; least-significant 32 bits of address

   583 static bool QT_FASTCALL _ls32(const char **ptr)

   584 {

   585     const char *ptrBackup = *ptr;

   586     if (_h16(ptr) && *((*ptr)++) == ':' && _h16(ptr)) 

   587         return true;

   588 

   589     *ptr = ptrBackup;

   590     return _IPv4Address(ptr);

   591 }

   592 

   593 // IPv6address =                            6( h16 ":" ) ls32 // case 1

   594 //             /                       "::" 5( h16 ":" ) ls32 // case 2

   595 //             / [               h16 ] "::" 4( h16 ":" ) ls32 // case 3

   596 //             / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 // case 4

   597 //             / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 // case 5

   598 //             / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32 // case 6

   599 //             / [ *4( h16 ":" ) h16 ] "::"              ls32 // case 7

   600 //             / [ *5( h16 ":" ) h16 ] "::"              h16  // case 8

   601 //             / [ *6( h16 ":" ) h16 ] "::"                   // case 9

   602 static bool QT_FASTCALL _IPv6Address(const char **ptr)

   603 {

   604     const char *ptrBackup = *ptr;

   605 

   606     // count of (h16 ":") to the left of and including ::

   607     int leftHexColons = 0;

   608     // count of (h16 ":") to the right of ::

   609     int rightHexColons = 0;

   610 

   611     // first count the number of (h16 ":") on the left of ::

   612     while (_h16(ptr)) {

   613 

   614         // an h16 not followed by a colon is considered an

   615         // error.

   616         if (**ptr != ':') {

   617             *ptr = ptrBackup;

   618             return false;

   619         }

   620         ++(*ptr);

   621         ++leftHexColons;

   622 

   623         // check for case 1, the only time when there can be no ::

   624         if (leftHexColons == 6 && _ls32(ptr)) {

   625             return true;

   626         }

   627     }

   628 

   629     // check for case 2 where the address starts with a :

   630     if (leftHexColons == 0 && *((*ptr)++) != ':') {

   631         *ptr = ptrBackup;

   632         return false;

   633     }

   634 

   635     // check for the second colon in ::

   636     if (*((*ptr)++) != ':') {

   637         *ptr = ptrBackup;

   638         return false;

   639     }

   640 

   641     int canBeCase = -1;

   642     bool ls32WasRead = false;

   643 

   644     const char *tmpBackup = *ptr;

   645 

   646     // count the number of (h16 ":") on the right of ::

   647     for (;;) {

   648         tmpBackup = *ptr;

   649         if (!_h16(ptr)) {

   650             if (!_ls32(ptr)) {

   651                 if (rightHexColons != 0) {

   652                     *ptr = ptrBackup;

   653                     return false;

   654                 }

   655 

   656                 // the address ended with :: (case 9)

   657                 // only valid if 1 <= leftHexColons <= 7

   658                 canBeCase = 9;

   659             } else {

   660                 ls32WasRead = true;

   661             }

   662             break;

   663         }

   664         ++rightHexColons;

   665         if (**ptr != ':') {

   666             // no colon could mean that what was read as an h16

   667             // was in fact the first part of an ls32. we backtrack

   668             // and retry.

   669             const char *pb = *ptr;

   670             *ptr = tmpBackup;

   671             if (_ls32(ptr)) {

   672                 ls32WasRead = true;

   673                 --rightHexColons;

   674             } else {

   675                 *ptr = pb;

   676                 // address ends with only 1 h16 after :: (case 8)

   677                 if (rightHexColons == 1)

   678                     canBeCase = 8;

   679             }

   680             break;

   681         }

   682         ++(*ptr);

   683     }

   684 

   685     // determine which case it is based on the number of rightHexColons

   686     if (canBeCase == -1) {

   687 

   688         // check if a ls32 was read. If it wasn't and rightHexColons >= 2 then the

   689         // last 2 HexColons are in fact a ls32

   690         if (!ls32WasRead && rightHexColons >= 2)

   691             rightHexColons -= 2;

   692 

   693         canBeCase = 7 - rightHexColons;

   694     }

   695 

   696     // based on the case we need to check that the number of leftHexColons is valid

   697     if (leftHexColons > (canBeCase - 2)) {

   698         *ptr = ptrBackup;

   699         return false;

   700     }

   701 

   702     return true;

   703 }

   704 

   705 // IP-literal = "[" ( IPv6address / IPvFuture  ) "]"

   706 static bool QT_FASTCALL _IPLiteral(const char **ptr)

   707 {

   708     const char *ptrBackup = *ptr;

   709     if (**ptr != '[')

   710         return false;

   711     ++(*ptr);

   712 

   713     if (!_IPv6Address(ptr) && !_IPvFuture(ptr)) {

   714         *ptr = ptrBackup;

   715         return false;

   716     }

   717 

   718     if (**ptr != ']') {

   719         *ptr = ptrBackup;

   720         return false;

   721     }

   722     ++(*ptr);

   723 

   724     return true;

   725 }

   726 

   727 // reg-name    = *( unreserved / pct-encoded / sub-delims )

   728 static void QT_FASTCALL _regName(const char **ptr)

   729 {

   730     for (;;) {

   731         if (!_unreserved(ptr) && !_subDelims(ptr)) {

   732             if (!_pctEncoded(ptr))

   733                 break;

   734         }

   735     }

   736 }

   737 

   738 // host        = IP-literal / IPv4address / reg-name

   739 static void QT_FASTCALL _host(const char **ptr, QUrlParseData *parseData)

   740 {

   741     parseData->host = *ptr;

   742     if (!_IPLiteral(ptr)) {

   743         if (_IPv4Address(ptr)) {

   744             char ch = **ptr;

   745             if (ch && ch != ':' && ch != '/') {

   746                 // reset

   747                 *ptr = parseData->host;

   748                 _regName(ptr);

   749             }

   750         } else {

   751             _regName(ptr);

   752         }

   753     }

   754     parseData->hostLength = *ptr - parseData->host;

   755 }

   756 

   757 // userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )

   758 static void QT_FASTCALL _userInfo(const char **ptr, QUrlParseData *parseData)

   759 {

   760     parseData->userInfo = *ptr;

   761     for (;;) {

   762         if (_unreserved(ptr) || _subDelims(ptr)) {

   763             ;

   764         } else {

   765             if (_pctEncoded(ptr)) {

   766                 ;

   767             } else if (**ptr == ':') {

   768                 parseData->userInfoDelimIndex = *ptr - parseData->userInfo;

   769                 ++(*ptr);

   770             } else {

   771                 break;

   772             }

   773         }

   774     }

   775     if (**ptr != '@') {

   776         *ptr = parseData->userInfo;

   777         parseData->userInfoDelimIndex = -1;

   778         return;

   779     }

   780     parseData->userInfoLength = *ptr - parseData->userInfo;

   781     ++(*ptr);

   782 }

   783 

   784 // port        = *DIGIT

   785 static void QT_FASTCALL _port(const char **ptr, int *port)

   786 {

   787     bool first = true;

   788 

   789     for (;;) {

   790         const char *ptrBackup = *ptr;

   791         char ch = *((*ptr)++);

   792         if (ch < '0' || ch > '9') {

   793             *ptr = ptrBackup;

   794             break;

   795         }

   796 

   797         if (first) {

   798             first = false;

   799             *port = 0;

   800         }

   801 

   802         *port *= 10;

   803         *port += ch - '0';

   804     }

   805 }

   806 

   807 // authority   = [ userinfo "@" ] host [ ":" port ]

   808 static void QT_FASTCALL _authority(const char **ptr, QUrlParseData *parseData)

   809 {

   810     _userInfo(ptr, parseData);

   811     _host(ptr, parseData);

   812 

   813     if (**ptr != ':') 

   814         return;

   815 

   816     ++(*ptr);

   817     _port(ptr, &parseData->port);

   818 }

   819 

   820 // pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"

   821 static bool QT_FASTCALL _pchar(const char **ptr)

   822 {

   823     char c = *(*ptr);

   824 

   825     switch (c) {

   826     case '!': case '$': case '&': case '\'': case '(': case ')': case '*':

   827     case '+': case ',': case ';': case '=': case ':': case '@':

   828     case '-': case '.': case '_': case '~':

   829         ++(*ptr);

   830         return true;

   831     default:

   832         break;

   833     };

   834 

   835     if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {

   836         ++(*ptr);

   837         return true;

   838     }

   839 

   840     if (_pctEncoded(ptr))

   841         return true;

   842 

   843     return false;

   844 }

   845 

   846 // segment       = *pchar

   847 static bool QT_FASTCALL _segmentNZ(const char **ptr)

   848 {

   849     if (!_pchar(ptr))

   850         return false;

   851 

   852     while(_pchar(ptr))

   853         ;

   854 

   855     return true;

   856 }

   857 

   858 // path-abempty  = *( "/" segment )

   859 static void QT_FASTCALL _pathAbEmpty(const char **ptr)

   860 {

   861     for (;;) {

   862         if (**ptr != '/') 

   863             break;

   864         ++(*ptr);

   865 

   866         while (_pchar(ptr))

   867             ;

   868     }

   869 }

   870 

   871 // path-abs      = "/" [ segment-nz *( "/" segment ) ]

   872 static bool QT_FASTCALL _pathAbs(const char **ptr)

   873 {

   874     // **ptr == '/' already checked in caller

   875     ++(*ptr);

   876 

   877     // we might be able to unnest this to gain some performance.

   878     if (!_segmentNZ(ptr))

   879         return true;

   880 

   881     _pathAbEmpty(ptr);

   882 

   883     return true;

   884 }

   885 

   886 // path-rootless = segment-nz *( "/" segment )

   887 static bool QT_FASTCALL _pathRootless(const char **ptr)

   888 {

   889     // we might be able to unnest this to gain some performance.

   890     if (!_segmentNZ(ptr))

   891         return false;

   892 

   893     _pathAbEmpty(ptr);

   894 

   895     return true;

   896 }

   897 

   898 

   899 // hier-part   = "//" authority path-abempty

   900 //             / path-abs

   901 //             / path-rootless

   902 //             / path-empty

   903 static void QT_FASTCALL _hierPart(const char **ptr, QUrlParseData *parseData)

   904 {

   905     const char *ptrBackup = *ptr;

   906     const char *pathStart = 0;

   907     if (*((*ptr)++) == '/' && *((*ptr)++) == '/') {

   908         _authority(ptr, parseData);

   909         pathStart = *ptr;

   910         _pathAbEmpty(ptr);

   911     } else {

   912         *ptr = ptrBackup;

   913         pathStart = *ptr;

   914         if (**ptr == '/')

   915             _pathAbs(ptr);

   916         else

   917             _pathRootless(ptr);

   918     }

   919     parseData->path = pathStart;

   920     parseData->pathLength = *ptr - pathStart;

   921 }

   922 

   923 // query       = *( pchar / "/" / "?" )

   924 static void QT_FASTCALL _query(const char **ptr, QUrlParseData *parseData)

   925 {

   926     parseData->query = *ptr;

   927     for (;;) {

   928         if (_pchar(ptr)) {

   929             ;

   930         } else if (**ptr == '/' || **ptr == '?') {

   931             ++(*ptr);

   932         } else {

   933             break;

   934         }

   935     }

   936     parseData->queryLength = *ptr - parseData->query;

   937 }

   938 

   939 // fragment    = *( pchar / "/" / "?" )

   940 static void QT_FASTCALL _fragment(const char **ptr, QUrlParseData *parseData)

   941 {

   942     parseData->fragment = *ptr;

   943     for (;;) {

   944         if (_pchar(ptr)) {

   945             ;

   946         } else if (**ptr == '/' || **ptr == '?' || **ptr == '#') {

   947             ++(*ptr);

   948         } else {

   949             break;

   950         }

   951     }

   952     parseData->fragmentLength = *ptr - parseData->fragment;

   953 }

   954 

   955 struct NameprepCaseFoldingEntry {

   956     int uc;

   957     ushort mapping[4];

   958 };

   959 

   960 inline bool operator<(int one, const NameprepCaseFoldingEntry &other)

   961 { return one < other.uc; }

   962 

   963 inline bool operator<(const NameprepCaseFoldingEntry &one, int other)

   964 { return one.uc < other; }

   965 

   966 static const NameprepCaseFoldingEntry NameprepCaseFolding[] = {

   967 /*	{ 0x0041, { 0x0061, 0x0000, 0x0000, 0x0000 } },

   968 	{ 0x0042, { 0x0062, 0x0000, 0x0000, 0x0000 } },

   969 	{ 0x0043, { 0x0063, 0x0000, 0x0000, 0x0000 } },

   970 	{ 0x0044, { 0x0064, 0x0000, 0x0000, 0x0000 } },

   971 	{ 0x0045, { 0x0065, 0x0000, 0x0000, 0x0000 } },

   972 	{ 0x0046, { 0x0066, 0x0000, 0x0000, 0x0000 } },

   973 	{ 0x0047, { 0x0067, 0x0000, 0x0000, 0x0000 } },

   974 	{ 0x0048, { 0x0068, 0x0000, 0x0000, 0x0000 } },

   975 	{ 0x0049, { 0x0069, 0x0000, 0x0000, 0x0000 } },

   976 	{ 0x004A, { 0x006A, 0x0000, 0x0000, 0x0000 } },

   977 	{ 0x004B, { 0x006B, 0x0000, 0x0000, 0x0000 } },

   978 	{ 0x004C, { 0x006C, 0x0000, 0x0000, 0x0000 } },

   979 	{ 0x004D, { 0x006D, 0x0000, 0x0000, 0x0000 } },

   980 	{ 0x004E, { 0x006E, 0x0000, 0x0000, 0x0000 } },

   981 	{ 0x004F, { 0x006F, 0x0000, 0x0000, 0x0000 } },

   982 	{ 0x0050, { 0x0070, 0x0000, 0x0000, 0x0000 } },

   983 	{ 0x0051, { 0x0071, 0x0000, 0x0000, 0x0000 } },

   984 	{ 0x0052, { 0x0072, 0x0000, 0x0000, 0x0000 } },

   985 	{ 0x0053, { 0x0073, 0x0000, 0x0000, 0x0000 } },

   986 	{ 0x0054, { 0x0074, 0x0000, 0x0000, 0x0000 } },

   987 	{ 0x0055, { 0x0075, 0x0000, 0x0000, 0x0000 } },

   988 	{ 0x0056, { 0x0076, 0x0000, 0x0000, 0x0000 } },

   989 	{ 0x0057, { 0x0077, 0x0000, 0x0000, 0x0000 } },

   990 	{ 0x0058, { 0x0078, 0x0000, 0x0000, 0x0000 } },

   991 	{ 0x0059, { 0x0079, 0x0000, 0x0000, 0x0000 } },

   992 	{ 0x005A, { 0x007A, 0x0000, 0x0000, 0x0000 } },*/

   993 	{ 0x00B5, { 0x03BC, 0x0000, 0x0000, 0x0000 } },

   994 	{ 0x00C0, { 0x00E0, 0x0000, 0x0000, 0x0000 } },

   995 	{ 0x00C1, { 0x00E1, 0x0000, 0x0000, 0x0000 } },

   996 	{ 0x00C2, { 0x00E2, 0x0000, 0x0000, 0x0000 } },

   997 	{ 0x00C3, { 0x00E3, 0x0000, 0x0000, 0x0000 } },

   998 	{ 0x00C4, { 0x00E4, 0x0000, 0x0000, 0x0000 } },

   999 	{ 0x00C5, { 0x00E5, 0x0000, 0x0000, 0x0000 } },

  1000 	{ 0x00C6, { 0x00E6, 0x0000, 0x0000, 0x0000 } },

  1001 	{ 0x00C7, { 0x00E7, 0x0000, 0x0000, 0x0000 } },

  1002 	{ 0x00C8, { 0x00E8, 0x0000, 0x0000, 0x0000 } },

  1003 	{ 0x00C9, { 0x00E9, 0x0000, 0x0000, 0x0000 } },

  1004 	{ 0x00CA, { 0x00EA, 0x0000, 0x0000, 0x0000 } },

  1005 	{ 0x00CB, { 0x00EB, 0x0000, 0x0000, 0x0000 } },

  1006 	{ 0x00CC, { 0x00EC, 0x0000, 0x0000, 0x0000 } },

  1007 	{ 0x00CD, { 0x00ED, 0x0000, 0x0000, 0x0000 } },

  1008 	{ 0x00CE, { 0x00EE, 0x0000, 0x0000, 0x0000 } },

  1009 	{ 0x00CF, { 0x00EF, 0x0000, 0x0000, 0x0000 } },

  1010 	{ 0x00D0, { 0x00F0, 0x0000, 0x0000, 0x0000 } },

  1011 	{ 0x00D1, { 0x00F1, 0x0000, 0x0000, 0x0000 } },

  1012 	{ 0x00D2, { 0x00F2, 0x0000, 0x0000, 0x0000 } },

  1013 	{ 0x00D3, { 0x00F3, 0x0000, 0x0000, 0x0000 } },

  1014 	{ 0x00D4, { 0x00F4, 0x0000, 0x0000, 0x0000 } },

  1015 	{ 0x00D5, { 0x00F5, 0x0000, 0x0000, 0x0000 } },

  1016 	{ 0x00D6, { 0x00F6, 0x0000, 0x0000, 0x0000 } },

  1017 	{ 0x00D8, { 0x00F8, 0x0000, 0x0000, 0x0000 } },

  1018 	{ 0x00D9, { 0x00F9, 0x0000, 0x0000, 0x0000 } },

  1019 	{ 0x00DA, { 0x00FA, 0x0000, 0x0000, 0x0000 } },

  1020 	{ 0x00DB, { 0x00FB, 0x0000, 0x0000, 0x0000 } },

  1021 	{ 0x00DC, { 0x00FC, 0x0000, 0x0000, 0x0000 } },

  1022 	{ 0x00DD, { 0x00FD, 0x0000, 0x0000, 0x0000 } },

  1023 	{ 0x00DE, { 0x00FE, 0x0000, 0x0000, 0x0000 } },

  1024 	{ 0x00DF, { 0x0073, 0x0073, 0x0000, 0x0000 } },

  1025 	{ 0x0100, { 0x0101, 0x0000, 0x0000, 0x0000 } },

  1026 	{ 0x0102, { 0x0103, 0x0000, 0x0000, 0x0000 } },

  1027 	{ 0x0104, { 0x0105, 0x0000, 0x0000, 0x0000 } },

  1028 	{ 0x0106, { 0x0107, 0x0000, 0x0000, 0x0000 } },

  1029 	{ 0x0108, { 0x0109, 0x0000, 0x0000, 0x0000 } },

  1030 	{ 0x010A, { 0x010B, 0x0000, 0x0000, 0x0000 } },

  1031 	{ 0x010C, { 0x010D, 0x0000, 0x0000, 0x0000 } },

  1032 	{ 0x010E, { 0x010F, 0x0000, 0x0000, 0x0000 } },

  1033 	{ 0x0110, { 0x0111, 0x0000, 0x0000, 0x0000 } },

  1034 	{ 0x0112, { 0x0113, 0x0000, 0x0000, 0x0000 } },

  1035 	{ 0x0114, { 0x0115, 0x0000, 0x0000, 0x0000 } },

  1036 	{ 0x0116, { 0x0117, 0x0000, 0x0000, 0x0000 } },

  1037 	{ 0x0118, { 0x0119, 0x0000, 0x0000, 0x0000 } },

  1038 	{ 0x011A, { 0x011B, 0x0000, 0x0000, 0x0000 } },

  1039 	{ 0x011C, { 0x011D, 0x0000, 0x0000, 0x0000 } },

  1040 	{ 0x011E, { 0x011F, 0x0000, 0x0000, 0x0000 } },

  1041 	{ 0x0120, { 0x0121, 0x0000, 0x0000, 0x0000 } },

  1042 	{ 0x0122, { 0x0123, 0x0000, 0x0000, 0x0000 } },

  1043 	{ 0x0124, { 0x0125, 0x0000, 0x0000, 0x0000 } },

  1044 	{ 0x0126, { 0x0127, 0x0000, 0x0000, 0x0000 } },

  1045 	{ 0x0128, { 0x0129, 0x0000, 0x0000, 0x0000 } },

  1046 	{ 0x012A, { 0x012B, 0x0000, 0x0000, 0x0000 } },

  1047 	{ 0x012C, { 0x012D, 0x0000, 0x0000, 0x0000 } },

  1048 	{ 0x012E, { 0x012F, 0x0000, 0x0000, 0x0000 } },

  1049 	{ 0x0130, { 0x0069, 0x0307, 0x0000, 0x0000 } },

  1050 	{ 0x0132, { 0x0133, 0x0000, 0x0000, 0x0000 } },

  1051 	{ 0x0134, { 0x0135, 0x0000, 0x0000, 0x0000 } },

  1052 	{ 0x0136, { 0x0137, 0x0000, 0x0000, 0x0000 } },

  1053 	{ 0x0139, { 0x013A, 0x0000, 0x0000, 0x0000 } },

  1054 	{ 0x013B, { 0x013C, 0x0000, 0x0000, 0x0000 } },

  1055 	{ 0x013D, { 0x013E, 0x0000, 0x0000, 0x0000 } },

  1056 	{ 0x013F, { 0x0140, 0x0000, 0x0000, 0x0000 } },

  1057 	{ 0x0141, { 0x0142, 0x0000, 0x0000, 0x0000 } },

  1058 	{ 0x0143, { 0x0144, 0x0000, 0x0000, 0x0000 } },

  1059 	{ 0x0145, { 0x0146, 0x0000, 0x0000, 0x0000 } },

  1060 	{ 0x0147, { 0x0148, 0x0000, 0x0000, 0x0000 } },

  1061 	{ 0x0149, { 0x02BC, 0x006E, 0x0000, 0x0000 } },

  1062 	{ 0x014A, { 0x014B, 0x0000, 0x0000, 0x0000 } },

  1063 	{ 0x014C, { 0x014D, 0x0000, 0x0000, 0x0000 } },

  1064 	{ 0x014E, { 0x014F, 0x0000, 0x0000, 0x0000 } },

  1065 	{ 0x0150, { 0x0151, 0x0000, 0x0000, 0x0000 } },

  1066 	{ 0x0152, { 0x0153, 0x0000, 0x0000, 0x0000 } },

  1067 	{ 0x0154, { 0x0155, 0x0000, 0x0000, 0x0000 } },

  1068 	{ 0x0156, { 0x0157, 0x0000, 0x0000, 0x0000 } },

  1069 	{ 0x0158, { 0x0159, 0x0000, 0x0000, 0x0000 } },

  1070 	{ 0x015A, { 0x015B, 0x0000, 0x0000, 0x0000 } },

  1071 	{ 0x015C, { 0x015D, 0x0000, 0x0000, 0x0000 } },

  1072 	{ 0x015E, { 0x015F, 0x0000, 0x0000, 0x0000 } },

  1073 	{ 0x0160, { 0x0161, 0x0000, 0x0000, 0x0000 } },

  1074 	{ 0x0162, { 0x0163, 0x0000, 0x0000, 0x0000 } },

  1075 	{ 0x0164, { 0x0165, 0x0000, 0x0000, 0x0000 } },

  1076 	{ 0x0166, { 0x0167, 0x0000, 0x0000, 0x0000 } },

  1077 	{ 0x0168, { 0x0169, 0x0000, 0x0000, 0x0000 } },

  1078 	{ 0x016A, { 0x016B, 0x0000, 0x0000, 0x0000 } },

  1079 	{ 0x016C, { 0x016D, 0x0000, 0x0000, 0x0000 } },

  1080 	{ 0x016E, { 0x016F, 0x0000, 0x0000, 0x0000 } },

  1081 	{ 0x0170, { 0x0171, 0x0000, 0x0000, 0x0000 } },

  1082 	{ 0x0172, { 0x0173, 0x0000, 0x0000, 0x0000 } },

  1083 	{ 0x0174, { 0x0175, 0x0000, 0x0000, 0x0000 } },

  1084 	{ 0x0176, { 0x0177, 0x0000, 0x0000, 0x0000 } },

  1085 	{ 0x0178, { 0x00FF, 0x0000, 0x0000, 0x0000 } },

  1086 	{ 0x0179, { 0x017A, 0x0000, 0x0000, 0x0000 } },

  1087 	{ 0x017B, { 0x017C, 0x0000, 0x0000, 0x0000 } },

  1088 	{ 0x017D, { 0x017E, 0x0000, 0x0000, 0x0000 } },

  1089 	{ 0x017F, { 0x0073, 0x0000, 0x0000, 0x0000 } },

  1090 	{ 0x0181, { 0x0253, 0x0000, 0x0000, 0x0000 } },

  1091 	{ 0x0182, { 0x0183, 0x0000, 0x0000, 0x0000 } },

  1092 	{ 0x0184, { 0x0185, 0x0000, 0x0000, 0x0000 } },

  1093 	{ 0x0186, { 0x0254, 0x0000, 0x0000, 0x0000 } },

  1094 	{ 0x0187, { 0x0188, 0x0000, 0x0000, 0x0000 } },

  1095 	{ 0x0189, { 0x0256, 0x0000, 0x0000, 0x0000 } },

  1096 	{ 0x018A, { 0x0257, 0x0000, 0x0000, 0x0000 } },

  1097 	{ 0x018B, { 0x018C, 0x0000, 0x0000, 0x0000 } },

  1098 	{ 0x018E, { 0x01DD, 0x0000, 0x0000, 0x0000 } },

  1099 	{ 0x018F, { 0x0259, 0x0000, 0x0000, 0x0000 } },

  1100 	{ 0x0190, { 0x025B, 0x0000, 0x0000, 0x0000 } },

  1101 	{ 0x0191, { 0x0192, 0x0000, 0x0000, 0x0000 } },

  1102 	{ 0x0193, { 0x0260, 0x0000, 0x0000, 0x0000 } },

  1103 	{ 0x0194, { 0x0263, 0x0000, 0x0000, 0x0000 } },

  1104 	{ 0x0196, { 0x0269, 0x0000, 0x0000, 0x0000 } },

  1105 	{ 0x0197, { 0x0268, 0x0000, 0x0000, 0x0000 } },

  1106 	{ 0x0198, { 0x0199, 0x0000, 0x0000, 0x0000 } },

  1107 	{ 0x019C, { 0x026F, 0x0000, 0x0000, 0x0000 } },

  1108 	{ 0x019D, { 0x0272, 0x0000, 0x0000, 0x0000 } },

  1109 	{ 0x019F, { 0x0275, 0x0000, 0x0000, 0x0000 } },

  1110 	{ 0x01A0, { 0x01A1, 0x0000, 0x0000, 0x0000 } },

  1111 	{ 0x01A2, { 0x01A3, 0x0000, 0x0000, 0x0000 } },

  1112 	{ 0x01A4, { 0x01A5, 0x0000, 0x0000, 0x0000 } },

  1113 	{ 0x01A6, { 0x0280, 0x0000, 0x0000, 0x0000 } },

  1114 	{ 0x01A7, { 0x01A8, 0x0000, 0x0000, 0x0000 } },

  1115 	{ 0x01A9, { 0x0283, 0x0000, 0x0000, 0x0000 } },

  1116 	{ 0x01AC, { 0x01AD, 0x0000, 0x0000, 0x0000 } },

  1117 	{ 0x01AE, { 0x0288, 0x0000, 0x0000, 0x0000 } },

  1118 	{ 0x01AF, { 0x01B0, 0x0000, 0x0000, 0x0000 } },

  1119 	{ 0x01B1, { 0x028A, 0x0000, 0x0000, 0x0000 } },

  1120 	{ 0x01B2, { 0x028B, 0x0000, 0x0000, 0x0000 } },

  1121 	{ 0x01B3, { 0x01B4, 0x0000, 0x0000, 0x0000 } },

  1122 	{ 0x01B5, { 0x01B6, 0x0000, 0x0000, 0x0000 } },

  1123 	{ 0x01B7, { 0x0292, 0x0000, 0x0000, 0x0000 } },

  1124 	{ 0x01B8, { 0x01B9, 0x0000, 0x0000, 0x0000 } },

  1125 	{ 0x01BC, { 0x01BD, 0x0000, 0x0000, 0x0000 } },

  1126 	{ 0x01C4, { 0x01C6, 0x0000, 0x0000, 0x0000 } },

  1127 	{ 0x01C5, { 0x01C6, 0x0000, 0x0000, 0x0000 } },

  1128 	{ 0x01C7, { 0x01C9, 0x0000, 0x0000, 0x0000 } },

  1129 	{ 0x01C8, { 0x01C9, 0x0000, 0x0000, 0x0000 } },

  1130 	{ 0x01CA, { 0x01CC, 0x0000, 0x0000, 0x0000 } },

  1131 	{ 0x01CB, { 0x01CC, 0x0000, 0x0000, 0x0000 } },

  1132 	{ 0x01CD, { 0x01CE, 0x0000, 0x0000, 0x0000 } },

  1133 	{ 0x01CF, { 0x01D0, 0x0000, 0x0000, 0x0000 } },

  1134 	{ 0x01D1, { 0x01D2, 0x0000, 0x0000, 0x0000 } },