FCL/sf/mw/qt: comparison src/corelib/io/qurl.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
 **
 Normalized = 0x4,
 HostCanonicalized = 0x8
 };
 int stateFlags;
-QByteArray encodedNormalized;
+mutable QByteArray encodedNormalized;
-const QByteArray & normalized();
+const QByteArray & normalized() const;
 mutable QUrlErrorInfo errorInfo;
 QString createErrorString();
 };
 }
 return false;
 }
 // scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
+static bool QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
 {
 bool first = true;
+bool isSchemeValid = true;
 parseData->scheme = *ptr;
 for (;;) {
 char ch = **ptr;
 if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
 ;
-} else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {
+} 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;
 }
 // IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
 static bool QT_FASTCALL _IPvFuture(const char **ptr)
 {
 QString aceForm; // this variable is here for caching
 while (1) {
 int idx = nextDotDelimiter(domain, lastIdx);
 int labelLength = idx - lastIdx;
-if (labelLength == 0)
+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
 #if defined (QURL_DEBUG)
 qDebug("QUrlPrivate::parse(), parsing \"%s\"", pptr);
 #endif
 // optional scheme
-_scheme(ptr, &parseData);
+bool isSchemeValid = _scheme(ptr, &parseData);
+if (isSchemeValid == false) {
+that->isValid = false;
+char ch = *((*ptr)++);
+that->errorInfo.setParams(*ptr, QT_TRANSLATE_NOOP(QUrl, "unexpected URL scheme"),
+0, ch);
+QURL_SETFLAG(that->stateFlags, Validated | Parsed);
+#if defined (QURL_DEBUG)
+qDebug("QUrlPrivate::parse(), unrecognized: %c%s", ch, *ptr);
+#endif
+return;
+}
 // hierpart
 _hierPart(ptr, &parseData);
 // optional query
 QByteArray QUrlPrivate::toEncoded(QUrl::FormattingOptions options) const
 {
 if (!QURL_HASFLAG(stateFlags, Parsed)) parse();
 else ensureEncodedParts();
+if (options==0x100) // private - see qHash(QUrl)
+return normalized();
 QByteArray url;
 if (!(options & QUrl::RemoveScheme) && !scheme.isEmpty()) {
 url += scheme.toLatin1();
 url += ':';
 if (doFileScheme && !encodedPath.startsWith('/'))
 url += '/';
 url += "//";
 if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
+bool hasUserOrPass = false;
 if (!userName.isEmpty()) {
 url += encodedUserName;
-if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
+hasUserOrPass = true;
-url += ':';
+}
-url += encodedPassword;
+if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
-}
+url += ':';
+url += encodedPassword;
+hasUserOrPass = true;
+}
+if (hasUserOrPass)
 url += '@';
-}
 }
 if (host.startsWith(QLatin1Char('['))) {
 url += host.toLatin1();
 } else if (host.contains(QLatin1Char(':'))) {
 return url;
 }
 #define qToLower(ch) (((ch|32) >= 'a' && (ch|32) <= 'z') ? (ch|32) : ch)
-const QByteArray &QUrlPrivate::normalized()
+const QByteArray &QUrlPrivate::normalized() const
 {
 if (QURL_HASFLAG(stateFlags, QUrlPrivate::Normalized))
 return encodedNormalized;
-QURL_SETFLAG(stateFlags, QUrlPrivate::Normalized);
+QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
+QURL_SETFLAG(that->stateFlags, QUrlPrivate::Normalized);
 QUrlPrivate tmp = *this;
 tmp.scheme = tmp.scheme.toLower();
 tmp.host = tmp.canonicalHost();
 \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 1
 \sa setUrl(), setEncodedUrl(), fromEncoded(), TolerantMode
 */
-QUrl::QUrl(const QString &url) : d(new QUrlPrivate)
+QUrl::QUrl(const QString &url) : d(0)
 {
 if (!url.isEmpty())
 setUrl(url);
 }
 Parses the \a url using the parser mode \a parsingMode.
 \sa setUrl()
 */
-QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d(new QUrlPrivate)
+QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d(0)
 {
 if (!url.isEmpty())
 setUrl(url, parsingMode);
-else
+else {
+d = new QUrlPrivate;
 d->parsingMode = parsingMode;
+}
 }
 /*!
 Constructs an empty QUrl object.
 */
-QUrl::QUrl() : d(new QUrlPrivate)
+QUrl::QUrl() : d(0)
 {
 }
 /*!
 Constructs a copy of \a other.
 */
 QUrl::QUrl(const QUrl &other) : d(other.d)
 {
-d->ref.ref();
+if (d)
+d->ref.ref();
 }
 /*!
 Destructor; called immediately before the object is deleted.
 */
 QUrl::~QUrl()
 {
-if (!d->ref.deref())
+if (d && !d->ref.deref())
 delete d;
 }
 /*!
 Returns true if the URL is valid; otherwise returns false.
 \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 2
 */
 bool QUrl::isValid() const
 {
+if (!d) return false;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
 return d->isValid;
 }
 /*!
 Returns true if the URL has no data; otherwise returns false.
 */
 bool QUrl::isEmpty() const
 {
+if (!d) return true;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed))
 return d->encodedOriginal.isEmpty();
 else
 return d->scheme.isEmpty()   // no encodedScheme
 && d->userName.isEmpty() && d->encodedUserName.isEmpty()
 QUrl is equal to one that has been constructed with the default
 empty constructor.
 */
 void QUrl::clear()
 {
-detach();
+if (d && !d->ref.deref())
-d->clear();
+delete d;
+d = 0;
 }
 /*!
 Constructs a URL by parsing the contents of \a url.
 Constructs a URL by parsing the contents of \a encodedUrl using
 the given \a parsingMode.
 */
 void QUrl::setEncodedUrl(const QByteArray &encodedUrl, ParsingMode parsingMode)
 {
-clear();
 QByteArray tmp = encodedUrl;
+if (!d) d = new QUrlPrivate;
+else d->clear();
 if ((d->parsingMode = parsingMode) == TolerantMode) {
 // Replace stray % with %25
 QByteArray copy = tmp;
 for (int i = 0, j = 0; i < copy.size(); ++i, ++j) {
 if (copy.at(i) == '%') {
 \sa scheme(), isRelative()
 */
 void QUrl::setScheme(const QString &scheme)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->scheme = scheme;
 \sa setScheme(), isRelative()
 */
 QString QUrl::scheme() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->scheme;
 }
 \img qurl-authority.png
 */
 void QUrl::setAuthority(const QString &authority)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->setAuthority(authority);
 \sa setAuthority()
 */
 QString QUrl::authority() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->authority();
 }
 \sa userInfo(), setUserName(), setPassword(), setAuthority()
 */
 void QUrl::setUserInfo(const QString &userInfo)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->setUserInfo(userInfo.trimmed());
 Returns the user info of the URL, or an empty string if the user
 info is undefined.
 */
 QString QUrl::userInfo() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->userInfo();
 }
 \sa setEncodedUserName(), userName(), setUserInfo()
 */
 void QUrl::setUserName(const QString &userName)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->userName = userName;
 \sa setUserName(), encodedUserName()
 */
 QString QUrl::userName() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->userInfo();              // causes the unencoded form to be set
 return d->userName;
 }
 \sa setUserName(), encodedUserName(), setUserInfo()
 */
 void QUrl::setEncodedUserName(const QByteArray &userName)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->encodedUserName = userName;
 \sa setEncodedUserName()
 */
 QByteArray QUrl::encodedUserName() const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->ensureEncodedParts();
 return d->encodedUserName;
 }
 \sa password(), setUserInfo()
 */
 void QUrl::setPassword(const QString &password)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->password = password;
 \sa setPassword()
 */
 QString QUrl::password() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->userInfo();              // causes the unencoded form to be set
 return d->password;
 }
 \sa setPassword(), encodedPassword(), setUserInfo()
 */
 void QUrl::setEncodedPassword(const QByteArray &password)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->encodedPassword = password;
 \sa setEncodedPassword(), toEncoded()
 */
 QByteArray QUrl::encodedPassword() const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->ensureEncodedParts();
 return d->encodedPassword;
 }
 \sa host(), setAuthority()
 */
 void QUrl::setHost(const QString &host)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized | QUrlPrivate::HostCanonicalized);
 d->host = host;
 Returns the host of the URL if it is defined; otherwise
 an empty string is returned.
 */
 QString QUrl::host() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (d->host.isEmpty() || d->host.at(0) != QLatin1Char('['))
 return d->canonicalHost();
 QString tmp = d->host.mid(1);
 \a port must be between 0 and 65535 inclusive. Setting the
 port to -1 indicates that the port is unspecified.
 */
 void QUrl::setPort(int port)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 if (port < -1 || port > 65535) {
 /*!
 Returns the port of the URL, or -1 if the port is unspecified.
 */
 int QUrl::port() const
 {
+if (!d) return -1;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
 return d->port;
 }
 \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 3
 */
 int QUrl::port(int defaultPort) const
 {
+if (!d) return defaultPort;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->port == -1 ? defaultPort : d->port;
 }
 /*!
 \sa path()
 */
 void QUrl::setPath(const QString &path)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->path = path;
 \sa setPath()
 */
 QString QUrl::path() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (d->path.isNull()) {
 QUrlPrivate *that = const_cast<QUrlPrivate *>(d);
 that->path = fromPercentEncodingHelper(d->encodedPath);
 \sa setPath(), encodedPath(), setUserInfo()
 */
 void QUrl::setEncodedPath(const QByteArray &path)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->encodedPath = path;
 \sa setEncodedPath(), toEncoded()
 */
 QByteArray QUrl::encodedPath() const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->ensureEncodedParts();
 return d->encodedPath;
 }
 \sa hasQueryItem(), encodedQuery()
 */
 bool QUrl::hasQuery() const
 {
+if (!d) return false;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->hasQuery;
 }
 current query string. It only affects queryItems(),
 setQueryItems() and addQueryItems().
 */
 void QUrl::setQueryDelimiters(char valueDelimiter, char pairDelimiter)
 {
+if (!d) d = new QUrlPrivate;
 detach();
 d->valueDelimiter = valueDelimiter;
 d->pairDelimiter = pairDelimiter;
 }
 Returns the character used to delimit between key-value pairs in
 the query string of the URL.
 */
 char QUrl::queryPairDelimiter() const
 {
+if (!d) return '&';
 return d->pairDelimiter;
 }
 /*!
 Returns the character used to delimit between keys and values in
 the query string of the URL.
 */
 char QUrl::queryValueDelimiter() const
 {
+if (!d) return '=';
 return d->valueDelimiter;
 }
 /*!
 Sets the query string of the URL to \a query. The string is
 \sa encodedQuery(), hasQuery()
 */
 void QUrl::setEncodedQuery(const QByteArray &query)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->query = query;
 \sa setQueryDelimiters(), queryItems(), setEncodedQueryItems()
 */
 void QUrl::setQueryItems(const QList<QPair<QString, QString> > &query)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 char alsoEncode[3];
 alsoEncode[0] = d->valueDelimiter;
 \sa setQueryDelimiters(), encodedQueryItems(), setQueryItems()
 */
 void QUrl::setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QByteArray queryTmp;
 for (int i = 0; i < query.size(); i++) {
 \sa addEncodedQueryItem()
 */
 void QUrl::addQueryItem(const QString &key, const QString &value)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 char alsoEncode[3];
 alsoEncode[0] = d->valueDelimiter;
 \sa addQueryItem(), setQueryDelimiters()
 */
 void QUrl::addEncodedQueryItem(const QByteArray &key, const QByteArray &value)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 if (!d->query.isEmpty())
 d->query += d->pairDelimiter;
 \sa setQueryItems(), setEncodedQuery()
 */
 QList<QPair<QString, QString> > QUrl::queryItems() const
 {
+if (!d) return QList<QPair<QString, QString> >();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QList<QPair<QString, QString> > itemMap;
 int pos = 0;
 \sa setEncodedQueryItems(), setQueryItems(), setEncodedQuery()
 */
 QList<QPair<QByteArray, QByteArray> > QUrl::encodedQueryItems() const
 {
+if (!d) return QList<QPair<QByteArray, QByteArray> >();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QList<QPair<QByteArray, QByteArray> > itemMap;
 int pos = 0;
 \sa hasEncodedQueryItem()
 */
 bool QUrl::hasQueryItem(const QString &key) const
 {
+if (!d) return false;
 return hasEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
 }
 /*!
 \since 4.4
 \sa hasQueryItem()
 */
 bool QUrl::hasEncodedQueryItem(const QByteArray &key) const
 {
+if (!d) return false;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 int pos = 0;
 const char *query = d->query.constData();
 while (pos < d->query.size()) {
 \sa allQueryItemValues()
 */
 QString QUrl::queryItemValue(const QString &key) const
 {
+if (!d) return QString();
 QByteArray tmp = encodedQueryItemValue(toPercentEncoding(key, queryExcludeChars));
 return fromPercentEncodingMutable(&tmp);
 }
 /*!
 \sa queryItemValue(), allQueryItemValues()
 */
 QByteArray QUrl::encodedQueryItemValue(const QByteArray &key) const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 int pos = 0;
 const char *query = d->query.constData();
 while (pos < d->query.size()) {
 \sa queryItemValue()
 */
 QStringList QUrl::allQueryItemValues(const QString &key) const
 {
+if (!d) return QStringList();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QByteArray encodedKey = toPercentEncoding(key, queryExcludeChars);
 QStringList values;
 \sa allQueryItemValues(), queryItemValue(), encodedQueryItemValue()
 */
 QList<QByteArray> QUrl::allEncodedQueryItemValues(const QByteArray &key) const
 {
+if (!d) return QList<QByteArray>();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QList<QByteArray> values;
 int pos = 0;
 \sa removeAllQueryItems()
 */
 void QUrl::removeQueryItem(const QString &key)
 {
+if (!d) return;
 removeEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
 }
 /*!
 \since 4.4
 \sa removeQueryItem(), removeAllQueryItems()
 */
 void QUrl::removeEncodedQueryItem(const QByteArray &key)
 {
+if (!d) return;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 int pos = 0;
 const char *query = d->query.constData();
 \sa removeQueryItem()
 */
 void QUrl::removeAllQueryItems(const QString &key)
 {
+if (!d) return;
 removeAllEncodedQueryItems(toPercentEncoding(key, queryExcludeChars));
 }
 /*!
 \since 4.4
 \sa removeQueryItem()
 */
 void QUrl::removeAllEncodedQueryItems(const QByteArray &key)
 {
+if (!d) return;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 int pos = 0;
 const char *query = d->query.constData();
 /*!
 Returns the query string of the URL in percent encoded form.
 */
 QByteArray QUrl::encodedQuery() const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->query;
 }
 \sa fragment(), hasFragment()
 */
 void QUrl::setFragment(const QString &fragment)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->fragment = fragment;
 \sa setFragment()
 */
 QString QUrl::fragment() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (d->fragment.isNull() && !d->encodedFragment.isNull()) {
 QUrlPrivate *that = const_cast<QUrlPrivate *>(d);
 that->fragment = fromPercentEncodingHelper(d->encodedFragment);
 \sa setFragment(), encodedFragment()
 */
 void QUrl::setEncodedFragment(const QByteArray &fragment)
 {
+if (!d) d = new QUrlPrivate;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 detach();
 QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
 d->encodedFragment = fragment;
 \sa setEncodedFragment(), toEncoded()
 */
 QByteArray QUrl::encodedFragment() const
 {
+if (!d) return QByteArray();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 d->ensureEncodedParts();
 return d->encodedFragment;
 }
 \sa fragment(), setFragment()
 */
 bool QUrl::hasFragment() const
 {
+if (!d) return false;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->hasFragment;
 }
 \sa isRelative()
 */
 QUrl QUrl::resolved(const QUrl &relative) const
 {
+if (!d) return relative;
+if (!relative.d) return *this;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (!QURL_HASFLAG(relative.d->stateFlags, QUrlPrivate::Parsed))
 relative.d->parse();
 t = relative;
 } else {
 if (!relative.authority().isEmpty()) {
 t = relative;
 } else {
+t.d = new QUrlPrivate;
 if (relative.d->encodedPath.isEmpty()) {
 t.d->encodedPath = d->encodedPath;
 t.setEncodedQuery(relative.d->hasQuery ? relative.d->query : d->query);
 } else {
 t.d->encodedPath = relative.d->encodedPath.at(0) == '/'
 URL is relative if its scheme is undefined; this function is
 therefore equivalent to calling scheme().isEmpty().
 */
 bool QUrl::isRelative() const
 {
+if (!d) return true;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 return d->scheme.isEmpty();
 }
 \sa FormattingOptions, toEncoded()
 */
 QString QUrl::toString(FormattingOptions options) const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QString url;
 if (!(options & QUrl::RemoveScheme) && !d->scheme.isEmpty())
 all non-ASCII characters are then percent encoded. The host name
 is encoded using Punycode.
 */
 QByteArray QUrl::toEncoded(FormattingOptions options) const
 {
+if (!d) return QByteArray();
 return d->toEncoded(options);
 }
 /*!
 Parses \a input and returns the corresponding QUrl. \a input is
 Returns true if this URL is "less than" the given \a url. This
 provides a means of ordering URLs.
 */
 bool QUrl::operator <(const QUrl &url) const
 {
+if (!d) return url.d ? QByteArray() < url.d->normalized() : false;
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+if (!url.d) return d->normalized() < QByteArray();
 if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
 return d->normalized() < url.d->normalized();
 }
 /*!
 Returns true if this URL and the given \a url are equal;
 otherwise returns false.
 */
 bool QUrl::operator ==(const QUrl &url) const
 {
+if (!d) return url.isEmpty();
+if (!url.d) return isEmpty();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
 return d->normalized() == url.d->normalized();
 }
 /*!
 Assigns the specified \a url to this object.
 */
 QUrl &QUrl::operator =(const QUrl &url)
 {
-qAtomicAssign(d, url.d);
+if (!d) {
+if (url.d) {
+url.d->ref.ref();
+d = url.d;
+}
+} else {
+if (url.d)
+qAtomicAssign(d, url.d);
+else
+clear();
+}
 return *this;
 }
 /*!
 Assigns the specified \a url to this object.
 */
 QUrl &QUrl::operator =(const QString &url)
 {
-QUrl tmp(url);
+if (url.isEmpty()) {
-qAtomicAssign(d, tmp.d);
+clear();
+} else {
+QUrl tmp(url);
+if (!d) d = new QUrlPrivate;
+qAtomicAssign(d, tmp.d);
+}
 return *this;
 }
 /*! \internal
 Forces a detach.
 */
 void QUrl::detach()
-{ qAtomicDetach(d); }
+{
+if (!d)
+d = new QUrlPrivate;
+else
+qAtomicDetach(d);
+}
 /*!
 \internal
 */
 bool QUrl::isDetached() const
 {
-return d->ref == 1;
+return !d || d->ref == 1;
 }
 /*!
 Returns a QUrl representation of \a localFile, interpreted as a
 \sa fromLocalFile()
 */
 QString QUrl::toLocalFile() const
 {
+if (!d) return QString();
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
 QString tmp;
 QString ourPath = path();
 if (d->scheme.isEmpty() || QString::compare(d->scheme, QLatin1String("file"), Qt::CaseInsensitive) == 0) {
 of this URL if the two URLs share the same scheme and authority,
 and this URL's path is a parent of the path of \a childUrl.
 */
 bool QUrl::isParentOf(const QUrl &childUrl) const
 {
+QString childPath = childUrl.path();
+if (!d)
+return ((childUrl.scheme().isEmpty())
+&& (childUrl.authority().isEmpty())
+&& childPath.length() > 0 && childPath.at(0) == QLatin1Char('/'));
 if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
-QString childPath = childUrl.path();
 QString ourPath = path();
 return ((childUrl.scheme().isEmpty() || d->scheme == childUrl.scheme())
 && (childUrl.authority().isEmpty() || d->authority() == childUrl.authority())
 &&  childPath.startsWith(ourPath)
 Returns a text string that explains why an URL is invalid in the case being;
 otherwise returns an empty string.
 */
 QString QUrl::errorString() const
 {
+if (!d)
+return QLatin1String(QT_TRANSLATE_NOOP(QUrl, "Invalid URL \"\": ")); // XXX not a good message, but the one an empty URL produces
 return d->createErrorString();
 }
 /*!
 \typedef QUrl::DataPtr

changeset 7	f7bc934e204c
parent 3	41300fa6a67c