qurl.cpp File Reference

#include "qplatformdefs.h"
#include "qurl.h"
#include "qatomic.h"
#include "qbytearray.h"
#include "qdir.h"
#include "qfile.h"
#include "qlist.h"
#include "qregexp.h"
#include "qstring.h"
#include "qstringlist.h"
#include "qstack.h"
#include "qvarlengtharray.h"
#include "qdebug.h"
#include "qtldurl_p.h"
#include "qmutex.h"
#include "private/qorderedmutexlocker_p.h"

Go to the source code of this file.

Classes
struct	NameprepCaseFoldingEntry
struct	QUrlErrorInfo
struct	QUrlParseData
class	QUrlPrivate

Macros
#define	ABNF_gen_delims   ":/?#[]@"
#define	ABNF_pchar   ABNF_sub_delims ":@"
#define	ABNF_reserved   ABNF_sub_delims ABNF_gen_delims
#define	ABNF_sub_delims   "!$&'()*+,;="
#define	Q_MAXINT   ((uint)((uint)(-1)>>1))
#define	qToLower(ch)   (((ch|32) >= 'a' && (ch|32) <= 'z') ? (ch|32) : ch)
#define	QURL_HASFLAG(a, b)   (((a) & (b)) == (b))
#define	QURL_SETFLAG(a, b)   { (a) |= (b); }
#define	QURL_UNSETFLAG(a, b)   { (a) &= ~(b); }

Enumerations
enum	AceOperation { ToAceOnly, NormalizeAce }

Functions
static void QT_FASTCALL	_authority (const char **ptr, QUrlParseData *parseData)
static bool QT_FASTCALL	_decOctet (const char **ptr)
static void QT_FASTCALL	_fragment (const char **ptr, QUrlParseData *parseData)
static bool QT_FASTCALL	_h16 (const char **ptr)
static bool QT_FASTCALL	_HEXDIG (const char **ptr)
static void QT_FASTCALL	_hierPart (const char **ptr, QUrlParseData *parseData)
static void QT_FASTCALL	_host (const char **ptr, QUrlParseData *parseData)
static bool QT_FASTCALL	_IPLiteral (const char **ptr)
static bool QT_FASTCALL	_IPv4Address (const char **ptr)
static bool QT_FASTCALL	_IPv6Address (const char **ptr)
static bool QT_FASTCALL	_IPvFuture (const char **ptr)
static bool QT_FASTCALL	_ls32 (const char **ptr)
static void QT_FASTCALL	_pathAbEmpty (const char **ptr)
static bool QT_FASTCALL	_pathAbs (const char **ptr)
static bool QT_FASTCALL	_pathRootless (const char **ptr)
static bool QT_FASTCALL	_pchar (const char **ptr)
static bool QT_FASTCALL	_pctEncoded (const char **ptr)
static void QT_FASTCALL	_port (const char **ptr, int *port)
static void QT_FASTCALL	_query (const char **ptr, QUrlParseData *parseData)
static void QT_FASTCALL	_regName (const char **ptr)
static bool QT_FASTCALL	_scheme (const char **ptr, QUrlParseData *parseData)
static bool QT_FASTCALL	_segmentNZ (const char **ptr)
static bool QT_FASTCALL	_subDelims (const char **ptr)
static bool QT_FASTCALL	_unreserved (const char **ptr)
static void QT_FASTCALL	_userInfo (const char **ptr, QUrlParseData *parseData)
static uint	adapt (uint delta, uint numpoints, bool firsttime)
static void	appendEncode (QString *output, uint &delta, uint &bias, uint &b, uint &h)
static bool	containsProhibitedOuptut (const QString *str, int from)
static uint	encodeDigit (uint digit)
static bool	equal (const QChar *a, int l, const char *b)
static QString	fromPercentEncodingHelper (const QByteArray &ba)
static QString	fromPercentEncodingMutable (QByteArray *ba)
static bool	isBidirectionalL (uint uc)
static bool	isBidirectionalRorAL (uint uc)
static bool	isDotDelimiter (ushort uc)
static bool	isHex (char c)
static bool	isMappedToNothing (uint uc)
static bool	lessThan (const QChar *a, int l, const char *c)
static void	mapToLowerCase (QString *str, int from)
static int	nextDotDelimiter (const QString &domain, int from=0)
bool	operator< (uint one, const NameprepCaseFoldingEntry &other)
bool	operator< (const NameprepCaseFoldingEntry &one, uint other)
QDebug	operator<< (QDebug d, const QUrl &url)
void	q_fromPercentEncoding (QByteArray *ba)
void	q_normalizePercentEncoding (QByteArray *ba, const char *exclude)
void	q_toPercentEncoding (QByteArray *ba, const char *exclude, const char *include=0)
Q_CORE_EXPORT int	qsnprintf (char *str, size_t n, const char *fmt,...)
static QString	qt_ACE_do (const QString &domain, AceOperation op)
static bool	qt_check_std3rules (const QChar *uc, int len)
static bool	qt_is_idn_enabled (const QString &domain)
static void	qt_nameprep (QString *source, int from)
static void	removeDotsFromPath (QByteArray *path)
static char	toHex (quint8 c)
static QByteArray	toPercentEncodingHelper (const QString &s, const char *exclude, const char *include=0)
static void	toPunycodeHelper (const QChar *s, int ucLength, QString *output)

Variables
static const uint	base = 36
static const uint	damp = 700
static const char	fragmentExcludeChars [] = ABNF_pchar "/?"
static const char *const	idn_whitelist []
static const uint	initial_bias = 72
static const uint	initial_n = 128
static const NameprepCaseFoldingEntry	NameprepCaseFolding []
static const char	passwordExcludeChars [] = ABNF_sub_delims ":"
static const char	pathExcludeChars [] = ABNF_pchar "/"
static const char	queryExcludeChars [] = ABNF_pchar "/?"
static const uint	skew = 38
static const uint	tmax = 26
static const uint	tmin = 1
static QStringList *	user_idn_whitelist = 0
static const char	userNameExcludeChars [] = ABNF_sub_delims

Macro Definition Documentation

ABNF_gen_delims

#define ABNF_gen_delims   ":/?#[]@"

Definition at line 3535 of file qurl.cpp.

ABNF_pchar

#define ABNF_pchar   ABNF_sub_delims ":@"

Definition at line 3536 of file qurl.cpp.

ABNF_reserved

#define ABNF_reserved   ABNF_sub_delims ABNF_gen_delims

Definition at line 3537 of file qurl.cpp.

Referenced by QUrl::setUrl().

ABNF_sub_delims

#define ABNF_sub_delims   "!$&'()*+,;="

Definition at line 3534 of file qurl.cpp.

Q_MAXINT

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

Definition at line 267 of file qurl.cpp.

Referenced by QUrl::fromPunycode(), and toPunycodeHelper().

qToLower

#define qToLower

(

ch

)

(((ch|32) >= 'a' && (ch|32) <= 'z') ? (ch|32) : ch)

Definition at line 4080 of file qurl.cpp.

Referenced by QUrlPrivate::normalized().

QURL_HASFLAG

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

Definition at line 278 of file qurl.cpp.

Referenced by QUrl::addEncodedQueryItem(), QUrl::addQueryItem(), QUrl::allEncodedQueryItemValues(), QUrl::allQueryItemValues(), QUrl::authority(), QUrlPrivate::canonicalHost(), QUrl::encodedFragment(), QUrl::encodedPassword(), QUrl::encodedPath(), QUrl::encodedQuery(), QUrl::encodedQueryItems(), QUrl::encodedQueryItemValue(), QUrl::encodedUserName(), QUrl::fragment(), QUrl::hasEncodedQueryItem(), QUrl::hasFragment(), QUrl::hasQuery(), QUrl::host(), QUrl::isEmpty(), QUrl::isLocalFile(), QUrl::isParentOf(), QUrl::isRelative(), QUrl::isValid(), QUrlPrivate::normalized(), QUrl::operator<(), QUrl::operator==(), QUrl::password(), QUrl::path(), QUrl::port(), QUrl::queryItems(), QUrl::removeAllEncodedQueryItems(), QUrl::removeEncodedQueryItem(), QUrl::resolved(), QUrl::scheme(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedQueryItems(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setQueryItems(), QUrl::setScheme(), QUrl::setUserInfo(), QUrl::setUserName(), QUrlPrivate::toEncoded(), QUrl::toString(), QUrl::userInfo(), and QUrl::userName().

QURL_SETFLAG

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

Definition at line 276 of file qurl.cpp.

Referenced by QUrlPrivate::canonicalHost(), QUrlPrivate::normalized(), QUrlPrivate::parse(), and QUrlPrivate::validate().

QURL_UNSETFLAG

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

Definition at line 277 of file qurl.cpp.

Referenced by QUrlPrivate::clear(), QUrlPrivate::parse(), QUrl::setAuthority(), QUrl::setEncodedFragment(), QUrl::setEncodedPassword(), QUrl::setEncodedPath(), QUrl::setEncodedQuery(), QUrl::setEncodedUserName(), QUrl::setFragment(), QUrl::setHost(), QUrl::setPassword(), QUrl::setPath(), QUrl::setPort(), QUrl::setScheme(), QUrl::setUserInfo(), and QUrl::setUserName().

Enumeration Type Documentation

AceOperation

enum AceOperation

Enumerator
ToAceOnly
NormalizeAce

Definition at line 3333 of file qurl.cpp.

{ ToAceOnly, NormalizeAce };

Function Documentation

_authority()

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

static

Definition at line 856 of file qurl.cpp.

Referenced by _hierPart().

{
    _userInfo(ptr, parseData);
    _host(ptr, parseData);

    if (**ptr != ':')
        return;

    ++(*ptr);
    _port(ptr, &parseData->port);
}

_decOctet()

static bool QT_FASTCALL _decOctet ( const char **  ptr )

static

Definition at line 567 of file qurl.cpp.

Referenced by _IPv4Address().

{
    const char *ptrBackup = *ptr;
    char c1 = **ptr;

    if (c1 < '0' || c1 > '9')
        return false;

    ++(*ptr);

    if (c1 == '0')
        return true;

    char c2 = **ptr;

    if (c2 < '0' || c2 > '9')
        return true;

    ++(*ptr);

    char c3 = **ptr;
    if (c3 < '0' || c3 > '9')
        return true;

    // If there is a three digit number larger than 255, reject the
    // whole token.
    if (c1 >= '2' && c2 >= '5' && c3 > '5') {
        *ptr = ptrBackup;
        return false;
    }

    ++(*ptr);

    return true;
}

_fragment()

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

static

Definition at line 988 of file qurl.cpp.

Referenced by QUrlPrivate::parse().

{
    parseData->fragment = *ptr;
    for (;;) {
        if (_pchar(ptr)) {
            ;
        } else if (**ptr == '/' || **ptr == '?' || **ptr == '#') {
            ++(*ptr);
        } else {
            break;
        }
    }
    parseData->fragmentLength = *ptr - parseData->fragment;
}

_h16()

static bool QT_FASTCALL _h16 ( const char **  ptr )

static

Definition at line 552 of file qurl.cpp.

Referenced by _IPv6Address(), and _ls32().

{
    int i = 0;
    for (; i < 4; ++i) {
        if (!_HEXDIG(ptr))
            break;
    }
    return (i != 0);
}

_HEXDIG()

static bool QT_FASTCALL _HEXDIG ( const char **  ptr )

static

Definition at line 404 of file qurl.cpp.

Referenced by _h16(), _IPvFuture(), and _pctEncoded().

{
    char ch = **ptr;
    if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {
        ++(*ptr);
        return true;
    }

    return false;
}

_hierPart()

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

static

Definition at line 951 of file qurl.cpp.

Referenced by QUrlPrivate::parse().

{
    const char *ptrBackup = *ptr;
    const char *pathStart = 0;
    if (*((*ptr)++) == '/' && *((*ptr)++) == '/') {
        _authority(ptr, parseData);
        pathStart = *ptr;
        _pathAbEmpty(ptr);
    } else {
        *ptr = ptrBackup;
        pathStart = *ptr;
        if (**ptr == '/')
            _pathAbs(ptr);
        else
            _pathRootless(ptr);
    }
    parseData->path = pathStart;
    parseData->pathLength = *ptr - pathStart;
}

_host()

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

static

Definition at line 787 of file qurl.cpp.

Referenced by _authority().

{
    parseData->host = *ptr;
    if (!_IPLiteral(ptr)) {
        if (_IPv4Address(ptr)) {
            char ch = **ptr;
            if (ch && ch != ':' && ch != '/') {
                // reset
                *ptr = parseData->host;
                _regName(ptr);
            }
        } else {
            _regName(ptr);
        }
    }
    parseData->hostLength = *ptr - parseData->host;
}

_IPLiteral()

static bool QT_FASTCALL _IPLiteral ( const char **  ptr )

static

Definition at line 754 of file qurl.cpp.

Referenced by _host(), and QUrlPrivate::canonicalHost().

{
    const char *ptrBackup = *ptr;
    if (**ptr != '[')
        return false;
    ++(*ptr);

    if (!_IPv6Address(ptr) && !_IPvFuture(ptr)) {
        *ptr = ptrBackup;
        return false;
    }

    if (**ptr != ']') {
        *ptr = ptrBackup;
        return false;
    }
    ++(*ptr);

    return true;
}

_IPv4Address()

static bool QT_FASTCALL _IPv4Address ( const char **  ptr )

static

Definition at line 604 of file qurl.cpp.

Referenced by _host(), and _ls32().

{
    const char *ptrBackup = *ptr;

    if (!_decOctet(ptr)) {
        *ptr = ptrBackup;
        return false;
    }

    for (int i = 0; i < 3; ++i) {
        char ch = *((*ptr)++);
        if (ch != '.') {
            *ptr = ptrBackup;
            return false;
        }

        if (!_decOctet(ptr)) {
            *ptr = ptrBackup;
            return false;
        }
    }

    return true;
}

_IPv6Address()

static bool QT_FASTCALL _IPv6Address ( const char **  ptr )

static

Definition at line 650 of file qurl.cpp.

Referenced by _IPLiteral().

{
    const char *ptrBackup = *ptr;

    // count of (h16 ":") to the left of and including ::
    int leftHexColons = 0;
    // count of (h16 ":") to the right of ::
    int rightHexColons = 0;

    // first count the number of (h16 ":") on the left of ::
    while (_h16(ptr)) {

        // an h16 not followed by a colon is considered an
        // error.
        if (**ptr != ':') {
            *ptr = ptrBackup;
            return false;
        }
        ++(*ptr);
        ++leftHexColons;

        // check for case 1, the only time when there can be no ::
        if (leftHexColons == 6 && _ls32(ptr)) {
            return true;
        }
    }

    // check for case 2 where the address starts with a :
    if (leftHexColons == 0 && *((*ptr)++) != ':') {
        *ptr = ptrBackup;
        return false;
    }

    // check for the second colon in ::
    if (*((*ptr)++) != ':') {
        *ptr = ptrBackup;
        return false;
    }

    int canBeCase = -1;
    bool ls32WasRead = false;

    const char *tmpBackup = *ptr;

    // count the number of (h16 ":") on the right of ::
    for (;;) {
        tmpBackup = *ptr;
        if (!_h16(ptr)) {
            if (!_ls32(ptr)) {
                if (rightHexColons != 0) {
                    *ptr = ptrBackup;
                    return false;
                }

                // the address ended with :: (case 9)
                // only valid if 1 <= leftHexColons <= 7
                canBeCase = 9;
            } else {
                ls32WasRead = true;
            }
            break;
        }
        ++rightHexColons;
        if (**ptr != ':') {
            // no colon could mean that what was read as an h16
            // was in fact the first part of an ls32. we backtrack
            // and retry.
            const char *pb = *ptr;
            *ptr = tmpBackup;
            if (_ls32(ptr)) {
                ls32WasRead = true;
                --rightHexColons;
            } else {
                *ptr = pb;
                // address ends with only 1 h16 after :: (case 8)
                if (rightHexColons == 1)
                    canBeCase = 8;
            }
            break;
        }
        ++(*ptr);
    }

    // determine which case it is based on the number of rightHexColons
    if (canBeCase == -1) {

        // check if a ls32 was read. If it wasn't and rightHexColons >= 2 then the
        // last 2 HexColons are in fact a ls32
        if (!ls32WasRead && rightHexColons >= 2)
            rightHexColons -= 2;

        canBeCase = 7 - rightHexColons;
    }

    // based on the case we need to check that the number of leftHexColons is valid
    if (leftHexColons > (canBeCase - 2)) {
        *ptr = ptrBackup;
        return false;
    }

    return true;
}

_IPvFuture()

static bool QT_FASTCALL _IPvFuture ( const char **  ptr )

static

Definition at line 516 of file qurl.cpp.

Referenced by _IPLiteral().

{
    if (**ptr != 'v')
        return false;

    const char *ptrBackup = *ptr;
    ++(*ptr);

    if (!_HEXDIG(ptr)) {
        *ptr = ptrBackup;
        return false;
    }

    while (_HEXDIG(ptr))
        ;

    if (**ptr != '.') {
        *ptr = ptrBackup;
        return false;
    }
    ++(*ptr);

    if (!_unreserved(ptr) && !_subDelims(ptr) && *((*ptr)++) != ':') {
        *ptr = ptrBackup;
        return false;
    }


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

    return true;
}

_ls32()

static bool QT_FASTCALL _ls32 ( const char **  ptr )

static

Definition at line 631 of file qurl.cpp.

Referenced by _IPv6Address().

{
    const char *ptrBackup = *ptr;
    if (_h16(ptr) && *((*ptr)++) == ':' && _h16(ptr))
        return true;

    *ptr = ptrBackup;
    return _IPv4Address(ptr);
}

_pathAbEmpty()

static void QT_FASTCALL _pathAbEmpty ( const char **  ptr )

static

Definition at line 907 of file qurl.cpp.

Referenced by _hierPart(), _pathAbs(), and _pathRootless().

{
    for (;;) {
        if (**ptr != '/')
            break;
        ++(*ptr);

        while (_pchar(ptr))
            ;
    }
}

_pathAbs()

static bool QT_FASTCALL _pathAbs ( const char **  ptr )

static

Definition at line 920 of file qurl.cpp.

Referenced by _hierPart().

{
    // **ptr == '/' already checked in caller
    ++(*ptr);

    // we might be able to unnest this to gain some performance.
    if (!_segmentNZ(ptr))
        return true;

    _pathAbEmpty(ptr);

    return true;
}

_pathRootless()

static bool QT_FASTCALL _pathRootless ( const char **  ptr )

static

Definition at line 935 of file qurl.cpp.

Referenced by _hierPart().

{
    // we might be able to unnest this to gain some performance.
    if (!_segmentNZ(ptr))
        return false;

    _pathAbEmpty(ptr);

    return true;
}

_pchar()

static bool QT_FASTCALL _pchar ( const char **  ptr )

static

Definition at line 869 of file qurl.cpp.

Referenced by _fragment(), _pathAbEmpty(), _query(), and _segmentNZ().

{
    char c = *(*ptr);

    switch (c) {
    case '!': case '$': case '&': case '\'': case '(': case ')': case '*':
    case '+': case ',': case ';': case '=': case ':': case '@':
    case '-': case '.': case '_': case '~':
        ++(*ptr);
        return true;
    default:
        break;
    };

    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
        ++(*ptr);
        return true;
    }

    if (_pctEncoded(ptr))
        return true;

    return false;
}

_pctEncoded()

static bool QT_FASTCALL _pctEncoded ( const char **  ptr )

static

Definition at line 416 of file qurl.cpp.

Referenced by _pchar(), _regName(), and _userInfo().

{
    const char *ptrBackup = *ptr;

    if (**ptr != '%')
        return false;
    ++(*ptr);

    if (!_HEXDIG(ptr)) {
        *ptr = ptrBackup;
        return false;
    }
    if (!_HEXDIG(ptr)) {
        *ptr = ptrBackup;
        return false;
    }

    return true;
}

_port()

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

static

Definition at line 833 of file qurl.cpp.

Referenced by _authority().

{
    bool first = true;

    for (;;) {
        const char *ptrBackup = *ptr;
        char ch = *((*ptr)++);
        if (ch < '0' || ch > '9') {
            *ptr = ptrBackup;
            break;
        }

        if (first) {
            first = false;
            *port = 0;
        }

        *port *= 10;
        *port += ch - '0';
    }
}

_query()

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

static

Definition at line 972 of file qurl.cpp.

Referenced by QUrlPrivate::parse().

{
    parseData->query = *ptr;
    for (;;) {
        if (_pchar(ptr)) {
            ;
        } else if (**ptr == '/' || **ptr == '?') {
            ++(*ptr);
        } else {
            break;
        }
    }
    parseData->queryLength = *ptr - parseData->query;
}

_regName()

static void QT_FASTCALL _regName ( const char **  ptr )

static

Definition at line 776 of file qurl.cpp.

Referenced by _host().

{
    for (;;) {
        if (!_unreserved(ptr) && !_subDelims(ptr)) {
            if (!_pctEncoded(ptr))
                break;
        }
    }
}

_scheme()

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

static

Definition at line 483 of file qurl.cpp.

Referenced by QUrlPrivate::parse().

{
    bool first = true;
    bool isSchemeValid = true;

    parseData->scheme = *ptr;
    for (;;) {
        char ch = **ptr;
        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
            ;
        } else if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.') {
            if (first)
                isSchemeValid = false;
        } else {
            break;
        }

        ++(*ptr);
        first = false;
    }

    if (**ptr != ':') {
        isSchemeValid = true;
        *ptr = parseData->scheme;
    } else {
        parseData->schemeLength = *ptr - parseData->scheme;
        ++(*ptr); // skip ':'
    }

    return isSchemeValid;
}

_segmentNZ()

static bool QT_FASTCALL _segmentNZ ( const char **  ptr )

static

Definition at line 895 of file qurl.cpp.

Referenced by _pathAbs(), and _pathRootless().

{
    if (!_pchar(ptr))
        return false;

    while(_pchar(ptr))
        ;

    return true;
}

_subDelims()

static bool QT_FASTCALL _subDelims ( const char **  ptr )

static

Definition at line 455 of file qurl.cpp.

Referenced by _IPvFuture(), _regName(), and _userInfo().

{
    char ch = **ptr;
    switch (ch) {
    case '!': case '$': case '&': case '\'':
    case '(': case ')': case '*': case '+':
    case ',': case ';': case '=':
        ++(*ptr);
        return true;
    default:
        return false;
    }
}

_unreserved()

static bool QT_FASTCALL _unreserved ( const char **  ptr )

static

Definition at line 470 of file qurl.cpp.

Referenced by _IPvFuture(), _regName(), and _userInfo().

{
    char ch = **ptr;
    if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
        || (ch >= '0' && ch <= '9')
        || ch == '-' || ch == '.' || ch == '_' || ch == '~') {
        ++(*ptr);
        return true;
    }
    return false;
}

_userInfo()

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

static

Definition at line 806 of file qurl.cpp.

Referenced by _authority().

{
    parseData->userInfo = *ptr;
    for (;;) {
        if (_unreserved(ptr) || _subDelims(ptr)) {
            ;
        } else {
            if (_pctEncoded(ptr)) {
                ;
            } else if (**ptr == ':') {
                parseData->userInfoDelimIndex = *ptr - parseData->userInfo;
                ++(*ptr);
            } else {
                break;
            }
        }
    }
    if (**ptr != '@') {
        *ptr = parseData->userInfo;
        parseData->userInfoDelimIndex = -1;
        return;
    }
    parseData->userInfoLength = *ptr - parseData->userInfo;
    ++(*ptr);
}

adapt()

static uint adapt ( uint  delta, uint  numpoints, bool  firsttime  )

inlinestatic

Definition at line 3104 of file qurl.cpp.

Referenced by appendEncode(), and QUrl::fromPunycode().

{
    delta /= (firsttime ? damp : 2);
    delta += (delta / numpoints);

    uint k = 0;
    for (; delta > ((base - tmin) * tmax) / 2; k += base)
        delta /= (base - tmin);

    return k + (((base - tmin + 1) * delta) / (delta + skew));
}

appendEncode()

static void appendEncode ( QString *  output, uint &  delta, uint &  bias, uint &  b, uint &  h  )

inlinestatic

Definition at line 3116 of file qurl.cpp.

Referenced by toPunycodeHelper().

{
    uint qq;
    uint k;
    uint t;

    // insert the variable length delta integer; fail on
    // overflow.
    for (qq = delta, k = base;; k += base) {
        // stop generating digits when the threshold is
        // detected.
        t = (k <= bias) ? tmin : (k >= bias + tmax) ? tmax : k - bias;
        if (qq < t) break;

        *output += QChar(encodeDigit(t + (qq - t) % (base - t)));
        qq = (qq - t) / (base - t);
    }

    *output += QChar(encodeDigit(qq));
    bias = adapt(delta, h + 1, h == b);
    delta = 0;
    ++h;
}

containsProhibitedOuptut()

static bool containsProhibitedOuptut ( const QString *  str, int  from  )

static

Definition at line 2450 of file qurl.cpp.

Referenced by qt_nameprep().

{
    const ushort *in = reinterpret_cast<const ushort *>(str->begin() + from);
    const ushort *end = (ushort *)str->data() + str->size();
    for ( ; in < end; ++in) {
        uint uc = *in;
        if (QChar(uc).isHighSurrogate() && in < end - 1) {
            ushort low = *(in + 1);
            if (QChar(low).isLowSurrogate()) {
                ++in;
                uc = QChar::surrogateToUcs4(uc, low);
            } else {
                // unpaired surrogates are prohibited
                return true;
            }
        }
        if (uc <= 0xFFFF) {
            if (uc < 0x80 ||
                !(uc <= 0x009F
                || uc == 0x00A0
                || uc == 0x0340
                || uc == 0x0341
                || uc == 0x06DD
                || uc == 0x070F
                || uc == 0x1680
                || uc == 0x180E
                || (uc >= 0x2000 && uc <= 0x200F)
                || (uc >= 0x2028 && uc <= 0x202F)
                || uc == 0x205F
                || (uc >= 0x2060 && uc <= 0x2063)
                || (uc >= 0x206A && uc <= 0x206F)
                || (uc >= 0x2FF0 && uc <= 0x2FFB)
                || uc == 0x3000
                || (uc >= 0xD800 && uc <= 0xDFFF)
                || (uc >= 0xE000 && uc <= 0xF8FF)
                || (uc >= 0xFDD0 && uc <= 0xFDEF)
                || uc == 0xFEFF
                || (uc >= 0xFFF9 && uc <= 0xFFFF))) {
                continue;
            }
        } else {
            if (!((uc >= 0x1D173 && uc <= 0x1D17A)
                || (uc >= 0x1FFFE && uc <= 0x1FFFF)
                || (uc >= 0x2FFFE && uc <= 0x2FFFF)
                || (uc >= 0x3FFFE && uc <= 0x3FFFF)
                || (uc >= 0x4FFFE && uc <= 0x4FFFF)
                || (uc >= 0x5FFFE && uc <= 0x5FFFF)
                || (uc >= 0x6FFFE && uc <= 0x6FFFF)
                || (uc >= 0x7FFFE && uc <= 0x7FFFF)
                || (uc >= 0x8FFFE && uc <= 0x8FFFF)
                || (uc >= 0x9FFFE && uc <= 0x9FFFF)
                || (uc >= 0xAFFFE && uc <= 0xAFFFF)
                || (uc >= 0xBFFFE && uc <= 0xBFFFF)
                || (uc >= 0xCFFFE && uc <= 0xCFFFF)
                || (uc >= 0xDFFFE && uc <= 0xDFFFF)
                || uc == 0xE0001
                || (uc >= 0xE0020 && uc <= 0xE007F)
                || (uc >= 0xEFFFE && uc <= 0xEFFFF)
                || (uc >= 0xF0000 && uc <= 0xFFFFD)
                || (uc >= 0xFFFFE && uc <= 0xFFFFF)
                || (uc >= 0x100000 && uc <= 0x10FFFD)
                || (uc >= 0x10FFFE && uc <= 0x10FFFF))) {
                continue;
            }
        }
        return true;
    }
    return false;
}

encodeDigit()

static uint encodeDigit ( uint  digit )

inlinestatic

Definition at line 3099 of file qurl.cpp.

Referenced by appendEncode().

{
  return digit + 22 + 75 * (digit < 26);
}

equal()

static bool equal ( const QChar *  a, int  l, const char *  b  )

static

Definition at line 3270 of file qurl.cpp.

Referenced by QDeclarativePropertyPrivate::canConvert(), QScriptValue::equals(), QDateTimeParser::findMonth(), QScriptDebuggerLocalsModel::init(), QAbstractXmlNodeModel::isDeepEqual(), parseHttpOptionHeader(), qt_create_commandline(), qt_is_idn_enabled(), and QProcessEnvironment::systemEnvironment().

{
    while (l && a->unicode() && *b) {
        if (*a != QLatin1Char(*b))
            return false;
        ++a;
        ++b;
        --l;
    }
    return l == 0;
}

fromPercentEncodingHelper()

static QString fromPercentEncodingHelper ( const QByteArray &  ba )

static

Definition at line 242 of file qurl.cpp.

Referenced by QUrlPrivate::fragmentImpl(), QUrl::fromPercentEncoding(), QUrlPrivate::parse(), QUrl::path(), QUrl::setEncodedHost(), and QUrlPrivate::userInfo().

{
    if (ba.isNull())
        return QString();       // null
    QByteArray copy = ba;
    q_fromPercentEncoding(&copy);
    return QString::fromUtf8(copy.constData(), copy.length());
}

fromPercentEncodingMutable()

static QString fromPercentEncodingMutable ( QByteArray *  ba )

static

Definition at line 251 of file qurl.cpp.

Referenced by QUrl::allQueryItemValues(), QUrlPrivate::parse(), QUrl::queryItems(), and QUrl::queryItemValue().

{
    if (ba->isNull())
        return QString();       // null
    q_fromPercentEncoding(ba);
    return QString::fromUtf8(ba->constData(), ba->length());
}

isBidirectionalL()

static bool isBidirectionalL ( uint  uc )

static

Definition at line 2560 of file qurl.cpp.

Referenced by qt_nameprep().

{
    if (uc < 0xaa)
        return (uc >= 0x0041 && uc <= 0x005A)
            || (uc >= 0x0061 && uc <= 0x007A);

    if (uc == 0x00AA
        || uc == 0x00B5
        || uc == 0x00BA
        || (uc >= 0x00C0 && uc <= 0x00D6)
        || (uc >= 0x00D8 && uc <= 0x00F6)
        || (uc >= 0x00F8 && uc <= 0x0220)
        || (uc >= 0x0222 && uc <= 0x0233)
        || (uc >= 0x0250 && uc <= 0x02AD)
        || (uc >= 0x02B0 && uc <= 0x02B8)
        || (uc >= 0x02BB && uc <= 0x02C1)
        || (uc >= 0x02D0 && uc <= 0x02D1)
        || (uc >= 0x02E0 && uc <= 0x02E4)
        || uc == 0x02EE
        || uc == 0x037A
        || uc == 0x0386
        || (uc >= 0x0388 && uc <= 0x038A)) {
        return true;
    }

    if (uc == 0x038C
        || (uc >= 0x038E && uc <= 0x03A1)
        || (uc >= 0x03A3 && uc <= 0x03CE)
        || (uc >= 0x03D0 && uc <= 0x03F5)
        || (uc >= 0x0400 && uc <= 0x0482)
        || (uc >= 0x048A && uc <= 0x04CE)
        || (uc >= 0x04D0 && uc <= 0x04F5)
        || (uc >= 0x04F8 && uc <= 0x04F9)
        || (uc >= 0x0500 && uc <= 0x050F)
        || (uc >= 0x0531 && uc <= 0x0556)
        || (uc >= 0x0559 && uc <= 0x055F)
        || (uc >= 0x0561 && uc <= 0x0587)
        || uc == 0x0589
        || uc == 0x0903
        || (uc >= 0x0905 && uc <= 0x0939)
        || (uc >= 0x093D && uc <= 0x0940)
        || (uc >= 0x0949 && uc <= 0x094C)
        || uc == 0x0950) {
        return true;
    }

    if ((uc >= 0x0958 && uc <= 0x0961)
        || (uc >= 0x0964 && uc <= 0x0970)
        || (uc >= 0x0982 && uc <= 0x0983)
        || (uc >= 0x0985 && uc <= 0x098C)
        || (uc >= 0x098F && uc <= 0x0990)
        || (uc >= 0x0993 && uc <= 0x09A8)
        || (uc >= 0x09AA && uc <= 0x09B0)
        || uc == 0x09B2
        || (uc >= 0x09B6 && uc <= 0x09B9)
        || (uc >= 0x09BE && uc <= 0x09C0)
        || (uc >= 0x09C7 && uc <= 0x09C8)
        || (uc >= 0x09CB && uc <= 0x09CC)
        || uc == 0x09D7
        || (uc >= 0x09DC && uc <= 0x09DD)
        || (uc >= 0x09DF && uc <= 0x09E1)
        || (uc >= 0x09E6 && uc <= 0x09F1)
        || (uc >= 0x09F4 && uc <= 0x09FA)
        || (uc >= 0x0A05 && uc <= 0x0A0A)
        || (uc >= 0x0A0F && uc <= 0x0A10)
        || (uc >= 0x0A13 && uc <= 0x0A28)
        || (uc >= 0x0A2A && uc <= 0x0A30)
        || (uc >= 0x0A32 && uc <= 0x0A33)) {
        return true;
    }

    if ((uc >= 0x0A35 && uc <= 0x0A36)
        || (uc >= 0x0A38 && uc <= 0x0A39)
        || (uc >= 0x0A3E && uc <= 0x0A40)
        || (uc >= 0x0A59 && uc <= 0x0A5C)
        || uc == 0x0A5E
        || (uc >= 0x0A66 && uc <= 0x0A6F)
        || (uc >= 0x0A72 && uc <= 0x0A74)
        || uc == 0x0A83
        || (uc >= 0x0A85 && uc <= 0x0A8B)
        || uc == 0x0A8D
        || (uc >= 0x0A8F && uc <= 0x0A91)
        || (uc >= 0x0A93 && uc <= 0x0AA8)
        || (uc >= 0x0AAA && uc <= 0x0AB0)
        || (uc >= 0x0AB2 && uc <= 0x0AB3)
        || (uc >= 0x0AB5 && uc <= 0x0AB9)
        || (uc >= 0x0ABD && uc <= 0x0AC0)
        || uc == 0x0AC9
        || (uc >= 0x0ACB && uc <= 0x0ACC)
        || uc == 0x0AD0
        || uc == 0x0AE0
        || (uc >= 0x0AE6 && uc <= 0x0AEF)
        || (uc >= 0x0B02 && uc <= 0x0B03)
        || (uc >= 0x0B05 && uc <= 0x0B0C)
        || (uc >= 0x0B0F && uc <= 0x0B10)
        || (uc >= 0x0B13 && uc <= 0x0B28)
        || (uc >= 0x0B2A && uc <= 0x0B30)) {
        return true;
    }

    if ((uc >= 0x0B32 && uc <= 0x0B33)
        || (uc >= 0x0B36 && uc <= 0x0B39)
        || (uc >= 0x0B3D && uc <= 0x0B3E)
        || uc == 0x0B40
        || (uc >= 0x0B47 && uc <= 0x0B48)
        || (uc >= 0x0B4B && uc <= 0x0B4C)
        || uc == 0x0B57
        || (uc >= 0x0B5C && uc <= 0x0B5D)
        || (uc >= 0x0B5F && uc <= 0x0B61)
        || (uc >= 0x0B66 && uc <= 0x0B70)
        || uc == 0x0B83
        || (uc >= 0x0B85 && uc <= 0x0B8A)
        || (uc >= 0x0B8E && uc <= 0x0B90)
        || (uc >= 0x0B92 && uc <= 0x0B95)
        || (uc >= 0x0B99 && uc <= 0x0B9A)
        || uc == 0x0B9C
        || (uc >= 0x0B9E && uc <= 0x0B9F)
        || (uc >= 0x0BA3 && uc <= 0x0BA4)
        || (uc >= 0x0BA8 && uc <= 0x0BAA)
        || (uc >= 0x0BAE && uc <= 0x0BB5)
        || (uc >= 0x0BB7 && uc <= 0x0BB9)
        || (uc >= 0x0BBE && uc <= 0x0BBF)
        || (uc >= 0x0BC1 && uc <= 0x0BC2)
        || (uc >= 0x0BC6 && uc <= 0x0BC8)
        || (uc >= 0x0BCA && uc <= 0x0BCC)
        || uc == 0x0BD7
        || (uc >= 0x0BE7 && uc <= 0x0BF2)
        || (uc >= 0x0C01 && uc <= 0x0C03)
        || (uc >= 0x0C05 && uc <= 0x0C0C)
        || (uc >= 0x0C0E && uc <= 0x0C10)
        || (uc >= 0x0C12 && uc <= 0x0C28)
        || (uc >= 0x0C2A && uc <= 0x0C33)
        || (uc >= 0x0C35 && uc <= 0x0C39)) {
        return true;
    }
    if ((uc >= 0x0C41 && uc <= 0x0C44)
        || (uc >= 0x0C60 && uc <= 0x0C61)
        || (uc >= 0x0C66 && uc <= 0x0C6F)
        || (uc >= 0x0C82 && uc <= 0x0C83)
        || (uc >= 0x0C85 && uc <= 0x0C8C)
        || (uc >= 0x0C8E && uc <= 0x0C90)
        || (uc >= 0x0C92 && uc <= 0x0CA8)
        || (uc >= 0x0CAA && uc <= 0x0CB3)
        || (uc >= 0x0CB5 && uc <= 0x0CB9)
        || uc == 0x0CBE
        || (uc >= 0x0CC0 && uc <= 0x0CC4)
        || (uc >= 0x0CC7 && uc <= 0x0CC8)
        || (uc >= 0x0CCA && uc <= 0x0CCB)
        || (uc >= 0x0CD5 && uc <= 0x0CD6)
        || uc == 0x0CDE
        || (uc >= 0x0CE0 && uc <= 0x0CE1)
        || (uc >= 0x0CE6 && uc <= 0x0CEF)
        || (uc >= 0x0D02 && uc <= 0x0D03)
        || (uc >= 0x0D05 && uc <= 0x0D0C)
        || (uc >= 0x0D0E && uc <= 0x0D10)
        || (uc >= 0x0D12 && uc <= 0x0D28)
        || (uc >= 0x0D2A && uc <= 0x0D39)
        || (uc >= 0x0D3E && uc <= 0x0D40)
        || (uc >= 0x0D46 && uc <= 0x0D48)
        || (uc >= 0x0D4A && uc <= 0x0D4C)
        || uc == 0x0D57
        || (uc >= 0x0D60 && uc <= 0x0D61)
        || (uc >= 0x0D66 && uc <= 0x0D6F)
        || (uc >= 0x0D82 && uc <= 0x0D83)
        || (uc >= 0x0D85 && uc <= 0x0D96)
        || (uc >= 0x0D9A && uc <= 0x0DB1)
        || (uc >= 0x0DB3 && uc <= 0x0DBB)
        || uc == 0x0DBD) {
        return true;
    }
    if ((uc >= 0x0DC0 && uc <= 0x0DC6)
        || (uc >= 0x0DCF && uc <= 0x0DD1)
        || (uc >= 0x0DD8 && uc <= 0x0DDF)
        || (uc >= 0x0DF2 && uc <= 0x0DF4)
        || (uc >= 0x0E01 && uc <= 0x0E30)
        || (uc >= 0x0E32 && uc <= 0x0E33)
        || (uc >= 0x0E40 && uc <= 0x0E46)
        || (uc >= 0x0E4F && uc <= 0x0E5B)
        || (uc >= 0x0E81 && uc <= 0x0E82)
        || uc == 0x0E84
        || (uc >= 0x0E87 && uc <= 0x0E88)
        || uc == 0x0E8A
        || uc == 0x0E8D
        || (uc >= 0x0E94 && uc <= 0x0E97)
        || (uc >= 0x0E99 && uc <= 0x0E9F)
        || (uc >= 0x0EA1 && uc <= 0x0EA3)
        || uc == 0x0EA5
        || uc == 0x0EA7
        || (uc >= 0x0EAA && uc <= 0x0EAB)
        || (uc >= 0x0EAD && uc <= 0x0EB0)
        || (uc >= 0x0EB2 && uc <= 0x0EB3)
        || uc == 0x0EBD
        || (uc >= 0x0EC0 && uc <= 0x0EC4)
        || uc == 0x0EC6
        || (uc >= 0x0ED0 && uc <= 0x0ED9)
        || (uc >= 0x0EDC && uc <= 0x0EDD)
        || (uc >= 0x0F00 && uc <= 0x0F17)
        || (uc >= 0x0F1A && uc <= 0x0F34)
        || uc == 0x0F36
        || uc == 0x0F38
        || (uc >= 0x0F3E && uc <= 0x0F47)
        || (uc >= 0x0F49 && uc <= 0x0F6A)
        || uc == 0x0F7F
        || uc == 0x0F85
        || (uc >= 0x0F88 && uc <= 0x0F8B)
        || (uc >= 0x0FBE && uc <= 0x0FC5)
        || (uc >= 0x0FC7 && uc <= 0x0FCC)
        || uc == 0x0FCF) {
        return true;
    }

    if ((uc >= 0x1000 && uc <= 0x1021)
        || (uc >= 0x1023 && uc <= 0x1027)
        || (uc >= 0x1029 && uc <= 0x102A)
        || uc == 0x102C
        || uc == 0x1031
        || uc == 0x1038
        || (uc >= 0x1040 && uc <= 0x1057)
        || (uc >= 0x10A0 && uc <= 0x10C5)
        || (uc >= 0x10D0 && uc <= 0x10F8)
        || uc == 0x10FB
        || (uc >= 0x1100 && uc <= 0x1159)
        || (uc >= 0x115F && uc <= 0x11A2)
        || (uc >= 0x11A8 && uc <= 0x11F9)
        || (uc >= 0x1200 && uc <= 0x1206)
        || (uc >= 0x1208 && uc <= 0x1246)
        || uc == 0x1248
        || (uc >= 0x124A && uc <= 0x124D)
        || (uc >= 0x1250 && uc <= 0x1256)
        || uc == 0x1258
        || (uc >= 0x125A && uc <= 0x125D)
        || (uc >= 0x1260 && uc <= 0x1286)
        || uc == 0x1288
        || (uc >= 0x128A && uc <= 0x128D)
        || (uc >= 0x1290 && uc <= 0x12AE)
        || uc == 0x12B0
        || (uc >= 0x12B2 && uc <= 0x12B5)
        || (uc >= 0x12B8 && uc <= 0x12BE)
        || uc == 0x12C0
        || (uc >= 0x12C2 && uc <= 0x12C5)
        || (uc >= 0x12C8 && uc <= 0x12CE)
        || (uc >= 0x12D0 && uc <= 0x12D6)
        || (uc >= 0x12D8 && uc <= 0x12EE)
        || (uc >= 0x12F0 && uc <= 0x130E)
        || uc == 0x1310) {
        return true;
    }

    if ((uc >= 0x1312 && uc <= 0x1315)
        || (uc >= 0x1318 && uc <= 0x131E)
        || (uc >= 0x1320 && uc <= 0x1346)
        || (uc >= 0x1348 && uc <= 0x135A)
        || (uc >= 0x1361 && uc <= 0x137C)
        || (uc >= 0x13A0 && uc <= 0x13F4)
        || (uc >= 0x1401 && uc <= 0x1676)
        || (uc >= 0x1681 && uc <= 0x169A)
        || (uc >= 0x16A0 && uc <= 0x16F0)
        || (uc >= 0x1700 && uc <= 0x170C)
        || (uc >= 0x170E && uc <= 0x1711)
        || (uc >= 0x1720 && uc <= 0x1731)
        || (uc >= 0x1735 && uc <= 0x1736)
        || (uc >= 0x1740 && uc <= 0x1751)
        || (uc >= 0x1760 && uc <= 0x176C)
        || (uc >= 0x176E && uc <= 0x1770)
        || (uc >= 0x1780 && uc <= 0x17B6)
        || (uc >= 0x17BE && uc <= 0x17C5)
        || (uc >= 0x17C7 && uc <= 0x17C8)
        || (uc >= 0x17D4 && uc <= 0x17DA)
        || uc == 0x17DC
        || (uc >= 0x17E0 && uc <= 0x17E9)
        || (uc >= 0x1810 && uc <= 0x1819)
        || (uc >= 0x1820 && uc <= 0x1877)
        || (uc >= 0x1880 && uc <= 0x18A8)
        || (uc >= 0x1E00 && uc <= 0x1E9B)
        || (uc >= 0x1EA0 && uc <= 0x1EF9)
        || (uc >= 0x1F00 && uc <= 0x1F15)
        || (uc >= 0x1F18 && uc <= 0x1F1D)
        || (uc >= 0x1F20 && uc <= 0x1F45)
        || (uc >= 0x1F48 && uc <= 0x1F4D)
        || (uc >= 0x1F50 && uc <= 0x1F57)
        || uc == 0x1F59
        || uc == 0x1F5B
        || uc == 0x1F5D) {
        return true;
    }

    if ((uc >= 0x1F5F && uc <= 0x1F7D)
        || (uc >= 0x1F80 && uc <= 0x1FB4)
        || (uc >= 0x1FB6 && uc <= 0x1FBC)
        || uc == 0x1FBE
        || (uc >= 0x1FC2 && uc <= 0x1FC4)
        || (uc >= 0x1FC6 && uc <= 0x1FCC)
        || (uc >= 0x1FD0 && uc <= 0x1FD3)
        || (uc >= 0x1FD6 && uc <= 0x1FDB)
        || (uc >= 0x1FE0 && uc <= 0x1FEC)
        || (uc >= 0x1FF2 && uc <= 0x1FF4)
        || (uc >= 0x1FF6 && uc <= 0x1FFC)
        || uc == 0x200E
        || uc == 0x2071
        || uc == 0x207F
        || uc == 0x2102
        || uc == 0x2107
        || (uc >= 0x210A && uc <= 0x2113)
        || uc == 0x2115
        || (uc >= 0x2119 && uc <= 0x211D)) {
        return true;
    }

    if (uc == 0x2124
        || uc == 0x2126
        || uc == 0x2128
        || (uc >= 0x212A && uc <= 0x212D)
        || (uc >= 0x212F && uc <= 0x2131)
        || (uc >= 0x2133 && uc <= 0x2139)
        || (uc >= 0x213D && uc <= 0x213F)
        || (uc >= 0x2145 && uc <= 0x2149)
        || (uc >= 0x2160 && uc <= 0x2183)
        || (uc >= 0x2336 && uc <= 0x237A)
        || uc == 0x2395
        || (uc >= 0x249C && uc <= 0x24E9)
        || (uc >= 0x3005 && uc <= 0x3007)
        || (uc >= 0x3021 && uc <= 0x3029)
        || (uc >= 0x3031 && uc <= 0x3035)
        || (uc >= 0x3038 && uc <= 0x303C)
        || (uc >= 0x3041 && uc <= 0x3096)
        || (uc >= 0x309D && uc <= 0x309F)
        || (uc >= 0x30A1 && uc <= 0x30FA)) {
        return true;
    }

    if ((uc >= 0x30FC && uc <= 0x30FF)
        || (uc >= 0x3105 && uc <= 0x312C)
        || (uc >= 0x3131 && uc <= 0x318E)
        || (uc >= 0x3190 && uc <= 0x31B7)
        || (uc >= 0x31F0 && uc <= 0x321C)
        || (uc >= 0x3220 && uc <= 0x3243)) {
        return true;
    }

    if ((uc >= 0x3260 && uc <= 0x327B)
        || (uc >= 0x327F && uc <= 0x32B0)
        || (uc >= 0x32C0 && uc <= 0x32CB)
        || (uc >= 0x32D0 && uc <= 0x32FE)
        || (uc >= 0x3300 && uc <= 0x3376)
        || (uc >= 0x337B && uc <= 0x33DD)) {
        return true;
    }
    if  ((uc >= 0x33E0 && uc <= 0x33FE)
         || (uc >= 0x3400 && uc <= 0x4DB5)
         || (uc >= 0x4E00 && uc <= 0x9FA5)
         || (uc >= 0xA000 && uc <= 0xA48C)
         || (uc >= 0xAC00 && uc <= 0xD7A3)
         || (uc >= 0xD800 && uc <= 0xFA2D)
         || (uc >= 0xFA30 && uc <= 0xFA6A)
         || (uc >= 0xFB00 && uc <= 0xFB06)
         || (uc >= 0xFB13 && uc <= 0xFB17)
         || (uc >= 0xFF21 && uc <= 0xFF3A)
         || (uc >= 0xFF41 && uc <= 0xFF5A)
         || (uc >= 0xFF66 && uc <= 0xFFBE)
         || (uc >= 0xFFC2 && uc <= 0xFFC7)
         || (uc >= 0xFFCA && uc <= 0xFFCF)
         || (uc >= 0xFFD2 && uc <= 0xFFD7)
         || (uc >= 0xFFDA && uc <= 0xFFDC)) {
        return true;
    }

    if ((uc >= 0x10300 && uc <= 0x1031E)
       || (uc >= 0x10320 && uc <= 0x10323)
       || (uc >= 0x10330 && uc <= 0x1034A)
       || (uc >= 0x10400 && uc <= 0x10425)
       || (uc >= 0x10428 && uc <= 0x1044D)
       || (uc >= 0x1D000 && uc <= 0x1D0F5)
       || (uc >= 0x1D100 && uc <= 0x1D126)
       || (uc >= 0x1D12A && uc <= 0x1D166)
       || (uc >= 0x1D16A && uc <= 0x1D172)
       || (uc >= 0x1D183 && uc <= 0x1D184)
       || (uc >= 0x1D18C && uc <= 0x1D1A9)
       || (uc >= 0x1D1AE && uc <= 0x1D1DD)
       || (uc >= 0x1D400 && uc <= 0x1D454)
       || (uc >= 0x1D456 && uc <= 0x1D49C)
       || (uc >= 0x1D49E && uc <= 0x1D49F)
       || uc == 0x1D4A2
       || (uc >= 0x1D4A5 && uc <= 0x1D4A6)
       || (uc >= 0x1D4A9 && uc <= 0x1D4AC)
       || (uc >= 0x1D4AE && uc <= 0x1D4B9)
       || uc == 0x1D4BB
       || (uc >= 0x1D4BD && uc <= 0x1D4C0)
       || (uc >= 0x1D4C2 && uc <= 0x1D4C3)
       || (uc >= 0x1D4C5 && uc <= 0x1D505)
       || (uc >= 0x1D507 && uc <= 0x1D50A)
       || (uc >= 0x1D50D && uc <= 0x1D514)
       || (uc >= 0x1D516 && uc <= 0x1D51C)
       || (uc >= 0x1D51E && uc <= 0x1D539)
       || (uc >= 0x1D53B && uc <= 0x1D53E)
       || (uc >= 0x1D540 && uc <= 0x1D544)
       || uc == 0x1D546
       || (uc >= 0x1D54A && uc <= 0x1D550)
       || (uc >= 0x1D552 && uc <= 0x1D6A3)
       || (uc >= 0x1D6A8 && uc <= 0x1D7C9)
       || (uc >= 0x20000 && uc <= 0x2A6D6)
       || (uc >= 0x2F800 && uc <= 0x2FA1D)
       || (uc >= 0xF0000 && uc <= 0xFFFFD)
       || (uc >= 0x100000 && uc <= 0x10FFFD)) {
        return true;
    }

    return false;
}

isBidirectionalRorAL()

static bool isBidirectionalRorAL ( uint  uc )

static

Definition at line 2520 of file qurl.cpp.

Referenced by qt_nameprep().

{
    if (uc < 0x5b0)
        return false;
    return uc == 0x05BE
        || uc == 0x05C0
        || uc == 0x05C3
        || (uc >= 0x05D0 && uc <= 0x05EA)
        || (uc >= 0x05F0 && uc <= 0x05F4)
        || uc == 0x061B
        || uc == 0x061F
        || (uc >= 0x0621 && uc <= 0x063A)
        || (uc >= 0x0640 && uc <= 0x064A)
        || (uc >= 0x066D && uc <= 0x066F)
        || (uc >= 0x0671 && uc <= 0x06D5)
        || uc == 0x06DD
        || (uc >= 0x06E5 && uc <= 0x06E6)
        || (uc >= 0x06FA && uc <= 0x06FE)
        || (uc >= 0x0700 && uc <= 0x070D)
        || uc == 0x0710
        || (uc >= 0x0712 && uc <= 0x072C)
        || (uc >= 0x0780 && uc <= 0x07A5)
        || uc == 0x07B1
        || uc == 0x200F
        || uc == 0xFB1D
        || (uc >= 0xFB1F && uc <= 0xFB28)
        || (uc >= 0xFB2A && uc <= 0xFB36)
        || (uc >= 0xFB38 && uc <= 0xFB3C)
        || uc == 0xFB3E
        || (uc >= 0xFB40 && uc <= 0xFB41)
        || (uc >= 0xFB43 && uc <= 0xFB44)
        || (uc >= 0xFB46 && uc <= 0xFBB1)
        || (uc >= 0xFBD3 && uc <= 0xFD3D)
        || (uc >= 0xFD50 && uc <= 0xFD8F)
        || (uc >= 0xFD92 && uc <= 0xFDC7)
        || (uc >= 0xFDF0 && uc <= 0xFDFC)
        || (uc >= 0xFE70 && uc <= 0xFE74)
        || (uc >= 0xFE76 && uc <= 0xFEFC);
}

isDotDelimiter()

static bool isDotDelimiter ( ushort  uc )

inlinestatic

Definition at line 3311 of file qurl.cpp.

Referenced by nextDotDelimiter().

{
    // IDNA / rfc3490 describes these four delimiters used for
    // separating labels in unicode international domain
    // names.
    return uc == 0x2e || uc == 0x3002 || uc == 0xff0e || uc == 0xff61;
}

isHex()

static bool isHex ( char  c )

inlinestatic

Definition at line 4434 of file qurl.cpp.

Referenced by QUrlPrivate::setEncodedUrl().

{
    c |= 0x20;
    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
}

isMappedToNothing()

static bool isMappedToNothing ( uint  uc )

static

Definition at line 2433 of file qurl.cpp.

Referenced by qt_nameprep().

{
    if (uc < 0xad)
        return false;
    switch (uc) {
    case 0x00AD: case 0x034F: case 0x1806: case 0x180B: case 0x180C: case 0x180D:
    case 0x200B: case 0x200C: case 0x200D: case 0x2060: case 0xFE00: case 0xFE01:
    case 0xFE02: case 0xFE03: case 0xFE04: case 0xFE05: case 0xFE06: case 0xFE07:
    case 0xFE08: case 0xFE09: case 0xFE0A: case 0xFE0B: case 0xFE0C: case 0xFE0D:
    case 0xFE0E: case 0xFE0F: case 0xFEFF:
        return true;
    default:
        return false;
    }
}

lessThan()

static bool lessThan ( const QChar *  a, int  l, const char *  c  )

static

Definition at line 3253 of file qurl.cpp.

Referenced by QPatternist::DerivedInteger< DerivedType >::fromValue(), QDeclarativeStyledTextPrivate::parse(), QAlgorithmsPrivate::qBinaryFindHelper(), QAlgorithmsPrivate::qLowerBoundHelper(), QAlgorithmsPrivate::qMerge(), QAlgorithmsPrivate::qSortHelper(), qt_is_idn_enabled(), QAlgorithmsPrivate::qUpperBoundHelper(), and sort().

{
    const ushort *uc = (const ushort *)a;
    const ushort *e = uc + l;

    if (!c || *c == 0)
        return false;

    while (*c) {
        if (uc == e || *uc != *c)
            break;
        ++uc;
        ++c;
    }
    return (uc == e ? *c : *uc < *c);
}

mapToLowerCase()

static void mapToLowerCase ( QString *  str, int  from  )

static

Definition at line 2388 of file qurl.cpp.

Referenced by qt_nameprep().

{
    int N = sizeof(NameprepCaseFolding) / sizeof(NameprepCaseFolding[0]);

    ushort *d = 0;
    for (int i = from; i < str->size(); ++i) {
        uint uc = str->at(i).unicode();
        if (uc < 0x80) {
            if (uc <= 'Z' && uc >= 'A') {
                if (!d)
                    d = reinterpret_cast<ushort *>(str->data());
                d[i] = (uc | 0x20);
            }
        } else {
            if (QChar(uc).isHighSurrogate() && i < str->size() - 1) {
                ushort low = str->at(i + 1).unicode();
                if (QChar(low).isLowSurrogate()) {
                    uc = QChar::surrogateToUcs4(uc, low);
                    ++i;
                }
            }
            const NameprepCaseFoldingEntry *entry = qBinaryFind(NameprepCaseFolding,
                                                                NameprepCaseFolding + N,
                                                                uc);
            if ((entry - NameprepCaseFolding) != N) {
                int l = 1;
                while (l < 4 && entry->mapping[l])
                    ++l;
                if (l > 1 || uc > 0xffff) {
                    if (uc <= 0xffff)
                        str->replace(i, 1, reinterpret_cast<const QChar *>(&entry->mapping[0]), l);
                    else
                        str->replace(--i, 2, reinterpret_cast<const QChar *>(&entry->mapping[0]), l);
                    i += l - 1;
                    d = 0;
                } else {
                    if (!d)
                        d = reinterpret_cast<ushort *>(str->data());
                    d[i] = entry->mapping[0];
                }
            }
        }
    }
}

nextDotDelimiter()

static int nextDotDelimiter ( const QString &  domain, int  from = 0  )

static

Definition at line 3319 of file qurl.cpp.

Referenced by qt_ACE_do().

{
    const QChar *b = domain.unicode();
    const QChar *ch = b + from;
    const QChar *e = b + domain.length();
    while (ch < e) {
        if (isDotDelimiter(ch->unicode()))
            break;
        else
            ++ch;
    }
    return ch - b;
}

operator<() [1/2]

bool operator< ( uint  one, const NameprepCaseFoldingEntry &  other  )

inline

Definition at line 1008 of file qurl.cpp.

{ return one < other.uc; }

operator<() [2/2]

bool operator< ( const NameprepCaseFoldingEntry &  one, uint  other  )

inline

Definition at line 1011 of file qurl.cpp.

{ return one.uc < other; }

operator<<()

QDebug operator<<	(	QDebug	d,
		const QUrl &	url
	)

Definition at line 6784 of file qurl.cpp.

{
    d.maybeSpace() << "QUrl(" << url.toString() << ')';
    return d.space();
}

q_fromPercentEncoding()

void q_fromPercentEncoding

(

QByteArray *

ba

)

Definition at line 4331 of file qbytearray.cpp.

Referenced by fromPercentEncodingHelper(), and fromPercentEncodingMutable().

{
    q_fromPercentEncoding(ba, '%');
}

q_normalizePercentEncoding()

void q_normalizePercentEncoding	(	QByteArray *	ba,
		const char *	exclude
	)

Definition at line 4429 of file qbytearray.cpp.

Referenced by QUrlPrivate::normalized().

{
    q_fromPercentEncoding(ba, '%');
    q_toPercentEncoding(ba, exclude, 0, '%');
}

q_toPercentEncoding()

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

Definition at line 4424 of file qbytearray.cpp.

Referenced by toPercentEncodingHelper().

{
    q_toPercentEncoding(ba, exclude, include, '%');
}

qsnprintf()

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

related

Referenced by QEventDispatcherUNIXPrivate::QEventDispatcherUNIXPrivate(), qt_x_errhandler(), and QEventDispatcherUNIXPrivate::~QEventDispatcherUNIXPrivate().

qt_ACE_do()

static QString qt_ACE_do ( const QString &  domain, AceOperation  op  )

static

Definition at line 3334 of file qurl.cpp.

Referenced by QUrlPrivate::canonicalHost(), QUrl::fromAce(), and QUrl::toAce().

{
    if (domain.isEmpty())
        return domain;

    QString result;
    result.reserve(domain.length());

    const bool isIdnEnabled = op == NormalizeAce ? qt_is_idn_enabled(domain) : false;
    int lastIdx = 0;
    QString aceForm; // this variable is here for caching

    while (1) {
        int idx = nextDotDelimiter(domain, lastIdx);
        int labelLength = idx - lastIdx;
        if (labelLength == 0) {
            if (idx == domain.length())
                break;
            return QString(); // two delimiters in a row -- empty label not allowed
        }

        // RFC 3490 says, about the ToASCII operation:
        //   3. If the UseSTD3ASCIIRules flag is set, then perform these checks:
        //
        //     (a) Verify the absence of non-LDH ASCII code points; that is, the
        //         absence of 0..2C, 2E..2F, 3A..40, 5B..60, and 7B..7F.
        //
        //     (b) Verify the absence of leading and trailing hyphen-minus; that
        //         is, the absence of U+002D at the beginning and end of the
        //         sequence.
        // and:
        //   8. Verify that the number of code points is in the range 1 to 63
        //      inclusive.

        // copy the label to the destination, which also serves as our scratch area, lowercasing it
        int prevLen = result.size();
        bool simple = true;
        result.resize(prevLen + labelLength);
        {
            QChar *out = result.data() + prevLen;
            const QChar *in = domain.constData() + lastIdx;
            const QChar *e = in + labelLength;
            for (; in < e; ++in, ++out) {
                register ushort uc = in->unicode();
                if (uc > 0x7f)
                    simple = false;
                if (uc >= 'A' && uc <= 'Z')
                    *out = QChar(uc | 0x20);
                else
                    *out = *in;
            }
        }

        if (simple && labelLength > 6) {
            // ACE form domains contain only ASCII characters, but we can't consider them simple
            // is this an ACE form?
            // the shortest valid ACE domain is 6 characters long (U+0080 would be 1, but it's not allowed)
            static const ushort acePrefixUtf16[] = { 'x', 'n', '-', '-' };
            if (memcmp(result.constData() + prevLen, acePrefixUtf16, sizeof acePrefixUtf16) == 0)
                simple = false;
        }

        if (simple) {
            // fastest case: this is the common case (non IDN-domains)
            // so we're done
            if (!qt_check_std3rules(result.constData() + prevLen, labelLength))
                return QString();
        } else {
            // Punycode encoding and decoding cannot be done in-place
            // That means we need one or two temporaries
            qt_nameprep(&result, prevLen);
            labelLength = result.length() - prevLen;
            register int toReserve = labelLength + 4 + 6; // "xn--" plus some extra bytes
            aceForm.resize(0);
            if (toReserve > aceForm.capacity())
                aceForm.reserve(toReserve);
            toPunycodeHelper(result.constData() + prevLen, result.size() - prevLen, &aceForm);

            // We use resize()+memcpy() here because we're overwriting the data we've copied
            if (isIdnEnabled) {
                QString tmp = QUrl::fromPunycode(aceForm.toLatin1());
                if (tmp.isEmpty())
                    return QString(); // shouldn't happen, since we've just punycode-encoded it
                result.resize(prevLen + tmp.size());
                memcpy(result.data() + prevLen, tmp.constData(), tmp.size() * sizeof(QChar));
            } else {
                result.resize(prevLen + aceForm.size());
                memcpy(result.data() + prevLen, aceForm.constData(), aceForm.size() * sizeof(QChar));
            }

            if (!qt_check_std3rules(aceForm.constData(), aceForm.size()))
                return QString();
        }


        lastIdx = idx + 1;
        if (lastIdx < domain.size() + 1)
            result += QLatin1Char('.');
        else
            break;
    }
    return result;
}

qt_check_std3rules()

bool qt_check_std3rules ( const QChar *  uc, int  len  )

static

Definition at line 3073 of file qurl.cpp.

Referenced by isBidirectionalL(), and qt_ACE_do().

{
    if (len > 63)
        return false;

    for (int i = 0; i < len; ++i) {
        register ushort c = uc[i].unicode();
        if (c == '-' && (i == 0 || i == len - 1))
            return false;

        // verifying the absence of LDH is the same as verifying that
        // only LDH is present
        if (c == '-' || (c >= '0' && c <= '9')
            || (c >= 'A' && c <= 'Z')
            || (c >= 'a' && c <= 'z')
            //underscore is not supposed to be allowed, but other browser accept it (QTBUG-7434)
            || c == '_')
            continue;

        return false;
    }

    return true;
}

qt_is_idn_enabled()

static bool qt_is_idn_enabled ( const QString &  domain )

static

Definition at line 3282 of file qurl.cpp.

Referenced by qt_ACE_do().

{
    int idx = domain.lastIndexOf(QLatin1Char('.'));
    if (idx == -1)
        return false;

    int len = domain.size() - idx - 1;
    QString tldString(domain.constData() + idx + 1, len);
    qt_nameprep(&tldString, 0);

    const QChar *tld = tldString.constData();

    if (user_idn_whitelist)
        return user_idn_whitelist->contains(tldString);

    int l = 0;
    int r = sizeof(idn_whitelist)/sizeof(const char *) - 1;
    int i = (l + r + 1) / 2;

    while (r != l) {
        if (lessThan(tld, len, idn_whitelist[i]))
            r = i - 1;
        else
            l = i;
        i = (l + r + 1) / 2;
    }
    return equal(tld, len, idn_whitelist[i]);
}

qt_nameprep()

void qt_nameprep ( QString *  source, int  from  )

static

Definition at line 2979 of file qurl.cpp.

Referenced by isBidirectionalL(), qt_ACE_do(), and qt_is_idn_enabled().

{
    QChar *src = source->data(); // causes a detach, so we're sure the only one using it
    QChar *out = src + from;
    const QChar *e = src + source->size();

    for ( ; out < e; ++out) {
        register ushort uc = out->unicode();
        if (uc >= 0x80) {
            break;
        } else if (uc >= 'A' && uc <= 'Z') {
            *out = QChar(uc | 0x20);
        }
    }
    if (out == e)
        return; // everything was mapped easily (lowercased, actually)
    int firstNonAscii = out - src;

    // Characters unassigned in Unicode 3.2 are not allowed in "stored string" scheme
    // but allowed in "query" scheme
    // (Table A.1)
    const bool isUnassignedAllowed = false; // ###
    // Characters commonly mapped to nothing are simply removed
    // (Table B.1)
    const QChar *in = out;
    for ( ; in < e; ++in) {
        uint uc = in->unicode();
        if (QChar(uc).isHighSurrogate() && in < e - 1) {
            ushort low = in[1].unicode();
            if (QChar(low).isLowSurrogate()) {
                ++in;
                uc = QChar::surrogateToUcs4(uc, low);
            }
        }
        if (!isUnassignedAllowed) {
            QChar::UnicodeVersion version = QChar::unicodeVersion(uc);
            if (version == QChar::Unicode_Unassigned || version > QChar::Unicode_3_2) {
                source->resize(from); // not allowed, clear the label
                return;
            }
        }
        if (!isMappedToNothing(uc)) {
            if (uc <= 0xFFFF) {
                *out++ = *in;
            } else {
                *out++ = in[-1];
                *out++ = in[0];
            }
        }
    }
    if (out != in)
        source->truncate(out - src);

    // Map to lowercase (Table B.2)
    mapToLowerCase(source, firstNonAscii);

    // Normalize to Unicode 3.2 form KC
    extern void qt_string_normalize(QString *data, QString::NormalizationForm mode,
                                    QChar::UnicodeVersion version, int from);
    qt_string_normalize(source, QString::NormalizationForm_KC, QChar::Unicode_3_2,
                        firstNonAscii > from ? firstNonAscii - 1 : from);

    // Strip prohibited output
    if (containsProhibitedOuptut(source, firstNonAscii)) {
        source->resize(from);
        return;
    }

    // Check for valid bidirectional characters
    bool containsLCat = false;
    bool containsRandALCat = false;
    src = source->data();
    e = src + source->size();
    for (in = src + from; in < e && (!containsLCat || !containsRandALCat); ++in) {
        uint uc = in->unicode();
        if (QChar(uc).isHighSurrogate() && in < e - 1) {
            ushort low = in[1].unicode();
            if (QChar(low).isLowSurrogate()) {
                ++in;
                uc = QChar::surrogateToUcs4(uc, low);
            }
        }
        if (isBidirectionalL(uc))
            containsLCat = true;
        else if (isBidirectionalRorAL(uc))
            containsRandALCat = true;
    }
    if (containsRandALCat) {
        if (containsLCat || (!isBidirectionalRorAL(src[from].unicode())
                             || !isBidirectionalRorAL(e[-1].unicode())))
            source->resize(from); // not allowed, clear the label
    }
}

removeDotsFromPath()

static void removeDotsFromPath ( QByteArray *  path )

static

Definition at line 3746 of file qurl.cpp.

Referenced by QUrlPrivate::normalized(), and QUrl::resolved().

{
    // The input buffer is initialized with the now-appended path
    // components and the output buffer is initialized to the empty
    // string.
    char *out = path->data();
    const char *in = out;
    const char *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] == '.')
        ++in;
    else if (path->size() == 2 && in[0] == '.' && in[1] == '.')
        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] == '.' && in[1] == '/')
            in += 2;
        else if (path->size() >= 3 && in[0] == '.' && in[1] == '.' && in[2] == '/')
            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] == '/' && in[1] == '.' && in[2] == '/') {
            in += 2;
            continue;
        } else if (in == end - 2 && in[0] == '/' && in[1] == '.') {
            *out++ = '/';
            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] == '/' && in[1] == '.' && in[2] == '.' && in[3] == '/') {
            while (out > path->constData() && *(--out) != '/')
                ;
            if (out == path->constData() && *out != '/')
                ++in;
            in += 3;
            continue;
        } else if (in == end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '.') {
            while (out > path->constData() && *(--out) != '/')
                ;
            if (*out == '/')
                ++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 != '/')
            *out++ = *in++;
    }
    path->truncate(out - path->constData());
}

toHex()

static char toHex ( quint8  c )

inlinestatic

Definition at line 4440 of file qurl.cpp.

Referenced by QPdfBaseEnginePrivate::drawTextItem(), QByteArray::isSharedWith(), QSharedMemoryPrivate::makePlatformSafeKey(), QUrlPrivate::setEncodedUrl(), and QTest::toHexRepresentation().

{
    return c > 9 ? c - 10 + 'A' : c + '0';
}

toPercentEncodingHelper()

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

static

Definition at line 233 of file qurl.cpp.

Referenced by QUrl::addQueryItem(), QUrlPrivate::ensureEncodedParts(), QUrl::setQueryItems(), QUrl::setUrl(), and QUrl::toPercentEncoding().

{
    if (s.isNull())
        return QByteArray();    // null
    QByteArray ba = s.toUtf8();
    q_toPercentEncoding(&ba, exclude, include);
    return ba;
}

toPunycodeHelper()

static void toPunycodeHelper ( const QChar *  s, int  ucLength, QString *  output  )

static

Definition at line 3140 of file qurl.cpp.

Referenced by qt_ACE_do(), and QUrl::toPunycode().

{
    uint n = initial_n;
    uint delta = 0;
    uint bias = initial_bias;

    int outLen = output->length();
    output->resize(outLen + ucLength);

    QChar *d = output->data() + outLen;
    bool skipped = false;
    // copy all basic code points verbatim to output.
    for (uint j = 0; j < (uint) ucLength; ++j) {
        ushort js = s[j].unicode();
        if (js < 0x80)
            *d++ = js;
        else
            skipped = true;
    }

    // if there were only basic code points, just return them
    // directly; don't do any encoding.
    if (!skipped)
        return;

    output->truncate(d - output->constData());
    int copied = output->size() - outLen;

    // h and b now contain the number of basic code points in input.
    uint b = copied;
    uint h = copied;

    // if basic code points were copied, add the delimiter character.
    if (h > 0)
        *output += QChar(0x2d);

    // while there are still unprocessed non-basic code points left in
    // the input string...
    while (h < (uint) ucLength) {
        // find the character in the input string with the lowest
        // unicode value.
        uint m = Q_MAXINT;
        uint j;
        for (j = 0; j < (uint) ucLength; ++j) {
            if (s[j].unicode() >= n && s[j].unicode() < m)
                m = (uint) s[j].unicode();
        }

        // reject out-of-bounds unicode characters
        if (m - n > (Q_MAXINT - delta) / (h + 1)) {
            output->truncate(outLen);
            return; // punycode_overflow
        }

        delta += (m - n) * (h + 1);
        n = m;

        // for each code point in the input string
        for (j = 0; j < (uint) ucLength; ++j) {

            // increase delta until we reach the character with the
            // lowest unicode code. fail if delta overflows.
            if (s[j].unicode() < n) {
                ++delta;
                if (!delta) {
                    output->truncate(outLen);
                    return; // punycode_overflow
                }
            }

            // if j is the index of the character with the lowest
            // unicode code...
            if (s[j].unicode() == n) {
                appendEncode(output, delta, bias, b, h);
            }
        }

        ++delta;
        ++n;
    }

    // prepend ACE prefix
    output->insert(outLen, QLatin1String("xn--"));
    return;
}

Variable Documentation

base

const uint base = 36

static

Definition at line 268 of file qurl.cpp.

Referenced by QScript::AST::ArrayMemberExpression::accept0(), QScript::AST::FieldMemberExpression::accept0(), QScript::AST::NewMemberExpression::accept0(), QScript::AST::CallExpression::accept0(), QScript::AST::PostIncrementExpression::accept0(), QScript::AST::PostDecrementExpression::accept0(), QDeclarativeJS::AST::ArrayMemberExpression::accept0(), QDeclarativeJS::AST::FieldMemberExpression::accept0(), QDeclarativeJS::AST::NewMemberExpression::accept0(), QDeclarativeJS::AST::CallExpression::accept0(), QDeclarativeJS::AST::PostIncrementExpression::accept0(), QDeclarativeJS::AST::PostDecrementExpression::accept0(), QAInterface::actionText(), adapt(), appendEncode(), QPdf::ascii85Encode(), QWSOnScreenSurface::attachToScreen(), QBidiControl::baseLevel(), QBidiControl::basicDirection(), cacheForNamespace(), QGraphicsAnchorLayoutPrivate::changeLayoutVertex(), QAInterface::childAt(), QAInterface::childCount(), QAInterface::className(), QBenchmarkValgrindUtils::cleanup(), QRasterPaintEngine::clip(), QtConcurrent::UnhandledException::clone(), convertPath(), QStyleSheetStyle::defaultSize(), QAInterface::doAction(), QTextLayout::drawCursor(), QPatternist::ResolveURIFN::evaluateSingleton(), QPatternist::BaseURIFN::evaluateSingleton(), QImageTextureGlyphCache::fillTexture(), QDeclarativeJS::AST::ArrayMemberExpression::firstSourceLocation(), QPatternist::AnyURI::fromLexical(), QUrl::fromPunycode(), QFileInfoGatherer::getFileInfos(), QBenchmarkValgrindUtils::getNewestFileName(), QTextStreamPrivate::getNumber(), QAInterface::indexOfChild(), QLCDNumberPrivate::init(), QAInterface::interfaceWrapper(), QString::isSharedWith(), QByteArray::isSharedWith(), QAInterface::isValid(), QPatternist::XsdSchemaChecker::isValidParticleExtension(), isZero(), QString::localeAwareCompare(), QStyleSheetStyle::nativeFrameWidth(), QAInterface::navigate(), QAInterface::object(), QPlainTextEdit::paintEvent(), QTextHtmlParser::parseEntity(), QPatternist::XsdSchemaParser::parseSimpleRestriction(), QTextStreamPrivate::putNumber(), QAInterface::QAInterface(), qDBusGenerateMetaObjectXml(), qForeachContainer(), QFileDialogPrivate::qt_mac_filedialog_event_proc(), qt_mac_flipPixmap(), qt_mix_colors(), qulltoa(), QFontEngineXLFD::recalcAdvances(), QAInterface::rect(), QUnixSocketMessagePrivate::removeBytes(), QAInterface::role(), QScriptEdit::setBaseLineNumber(), QPalette::setBrush(), QRasterPaintEngine::setClipRectInDeviceCoords(), QWSSharedMemSurface::setGeometry(), QTextStream::setIntegerBase(), QWSSharedMemSurface::setPermanentState(), QAInterface::setText(), QObjectPrivate::signalIndex(), QCleanlooksStyle::standardPalette(), QGtkStyle::standardPalette(), QAInterface::state(), QLocalePrivate::stringToLongLong(), QLocalePrivate::stringToUnsLongLong(), QAInterface::text(), QPatternist::AbstractDateTime::timeToString(), QPatternist::XQueryTokenizer::tokenizeCharacterReference(), toUrl(), QAInterface::userActionCount(), QDeclarativeTimeLinePrivate::value(), QTreeWidget::visualItemRect(), and QString::vsprintf().

damp

const uint damp = 700

static

Definition at line 272 of file qurl.cpp.

Referenced by adapt().

fragmentExcludeChars

const char fragmentExcludeChars[] = ABNF_pchar "/?"

static

Definition at line 3548 of file qurl.cpp.

Referenced by QUrlPrivate::ensureEncodedParts(), and QUrlPrivate::normalized().

idn_whitelist

const char* const idn_whitelist[]

static

Initial value:

= {
    "ac", "ar", "at",
    "biz", "br",
    "cat", "ch", "cl", "cn",
    "de", "dk",
    "es",
    "fi",
    "gr",
    "hu",
    "info", "io", "is",
    "jp",
    "kr",
    "li", "lt",
    "museum",
    "no",
    "org",
    "se", "sh",
    "th", "tm", "tw",
    "vn",
    "xn--mgbaam7a8h",           
    "xn--mgberp4a5d4ar",        
    "xn--wgbh1c"                
}

Definition at line 3227 of file qurl.cpp.

Referenced by QUrl::idnWhitelist(), and qt_is_idn_enabled().

initial_bias

const uint initial_bias = 72

static

Definition at line 273 of file qurl.cpp.

Referenced by QUrl::fromPunycode(), and toPunycodeHelper().

initial_n

const uint initial_n = 128

static

Definition at line 274 of file qurl.cpp.

Referenced by QUrl::fromPunycode(), and toPunycodeHelper().

NameprepCaseFolding

const NameprepCaseFoldingEntry NameprepCaseFolding[]

static

Definition at line 1014 of file qurl.cpp.

Referenced by mapToLowerCase().

passwordExcludeChars

const char passwordExcludeChars[] = ABNF_sub_delims ":"

static

Definition at line 3545 of file qurl.cpp.

Referenced by QUrlPrivate::ensureEncodedParts(), and QUrlPrivate::normalized().

pathExcludeChars

const char pathExcludeChars[] = ABNF_pchar "/"

static

Definition at line 3546 of file qurl.cpp.

Referenced by QUrlPrivate::ensureEncodedParts(), and QUrlPrivate::normalized().

queryExcludeChars

const char queryExcludeChars[] = ABNF_pchar "/?"

static

Definition at line 3547 of file qurl.cpp.

Referenced by QUrl::addQueryItem(), QUrl::allQueryItemValues(), QUrl::hasQueryItem(), QUrl::queryItemValue(), QUrl::removeAllQueryItems(), QUrl::removeQueryItem(), and QUrl::setQueryItems().

skew

const uint skew = 38

static

Definition at line 271 of file qurl.cpp.

Referenced by adapt().

tmax

const uint tmax = 26

static

Definition at line 270 of file qurl.cpp.

Referenced by adapt(), appendEncode(), and QUrl::fromPunycode().

tmin

const uint tmin = 1

static

Definition at line 269 of file qurl.cpp.

Referenced by adapt(), and QUrl::fromPunycode().

user_idn_whitelist

QStringList* user_idn_whitelist = 0

static

Definition at line 3251 of file qurl.cpp.

Referenced by QUrl::idnWhitelist().

userNameExcludeChars

const char userNameExcludeChars[] = ABNF_sub_delims

static

Definition at line 3544 of file qurl.cpp.

Referenced by QUrlPrivate::ensureEncodedParts(), and QUrlPrivate::normalized().