Merge branch 'master' of git@scm.dev.nokia.troll.no:qt/qt

Conflicts:
	src/corelib/io/qprocess.h

9 files changed, 487 insertions, 126 deletions

diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp
index 5e1a5e7..026c1fd 100644
--- a/src/corelib/io/qfile.cpp
+++ b/src/corelib/io/qfile.cpp
@@ -52,10 +52,6 @@
 # include "qcoreapplication.h"
 #endif
 
-#if !defined(Q_OS_WINCE)
-#include <errno.h>
-#endif
-
 #ifdef QT_NO_QOBJECT
 #define tr(X) QString::fromLatin1(X)
 #endif
@@ -653,11 +649,7 @@ QFile::remove()
             unsetError();
             return true;
         }
-#if defined(Q_OS_WIN)
-        d->setError(QFile::RemoveError, GetLastError());
-#else
-        d->setError(QFile::RemoveError, errno);
-#endif
+        d->setError(QFile::RemoveError, fileEngine()->errorString());
     }
     return false;
 }
@@ -812,7 +804,7 @@ QFile::link(const QString &linkName)
         unsetError();
         return true;
     }
-    d->setError(QFile::RenameError, errno);
+    d->setError(QFile::RenameError, fileEngine()->errorString());
     return false;
 }
 
@@ -1258,7 +1250,7 @@ QFile::resize(qint64 sz)
         unsetError();
         return true;
     }
-    d->setError(QFile::ResizeError, errno);
+    d->setError(QFile::ResizeError, fileEngine()->errorString());
     return false;
 }
 
@@ -1322,7 +1314,7 @@ QFile::setPermissions(Permissions permissions)
         unsetError();
         return true;
     }
-    d->setError(QFile::PermissionsError, errno);
+    d->setError(QFile::PermissionsError, fileEngine()->errorString());
     return false;
 }
 
@@ -1478,7 +1470,7 @@ bool QFile::seek(qint64 off)
         d->setError(err, fileEngine()->errorString());
         return false;
     }
-    d->error = NoError;
+    unsetError();
     return true;
 }
 
@@ -1506,7 +1498,7 @@ qint64 QFile::readLineData(char *data, qint64 maxlen)
 qint64 QFile::readData(char *data, qint64 len)
 {
     Q_D(QFile);
-    d->error = NoError;
+    unsetError();
     if (!d->ensureFlushed())
         return -1;
 
@@ -1588,7 +1580,7 @@ qint64
 QFile::writeData(const char *data, qint64 len)
 {
     Q_D(QFile);
-    d->error = NoError;
+    unsetError();
     d->lastWasWrite = true;
     bool buffered = !(d->openMode & Unbuffered);
 
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 4ee5c68..3bc2616 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -394,7 +394,10 @@ bool QFSFileEnginePrivate::nativeIsSequential() const
 bool QFSFileEngine::remove()
 {
     Q_D(QFSFileEngine);
-    return unlink(d->nativeFilePath.constData()) == 0;
+    bool ret = unlink(d->nativeFilePath.constData()) == 0;
+    if (!ret)
+        setError(QFile::RemoveError, qt_error_string(errno));
+    return ret;
 }
 
 bool QFSFileEngine::copy(const QString &newName)
@@ -422,6 +425,7 @@ bool QFSFileEngine::copy(const QString &newName)
     return (err == KErrNone);
 #else
     // ### Add copy code for Unix here
+    setError(QFile::UnspecifiedError, QLatin1String("Not implemented!"));
     return false;
 #endif
 }
@@ -429,13 +433,19 @@ bool QFSFileEngine::copy(const QString &newName)
 bool QFSFileEngine::rename(const QString &newName)
 {
     Q_D(QFSFileEngine);
-    return ::rename(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+    bool ret = ::rename(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+    if (!ret)
+        setError(QFile::RenameError, qt_error_string(errno));
+    return ret;
 }
 
 bool QFSFileEngine::link(const QString &newName)
 {
     Q_D(QFSFileEngine);
-    return ::symlink(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+    bool ret = ::symlink(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+    if (!ret)
+        setError(QFile::RenameError, qt_error_string(errno));
+    return ret;
 }
 
 qint64 QFSFileEnginePrivate::nativeSize() const
@@ -1143,6 +1153,7 @@ QString QFSFileEngine::owner(FileOwner own) const
 bool QFSFileEngine::setPermissions(uint perms)
 {
     Q_D(QFSFileEngine);
+    bool ret = false;
     mode_t mode = 0;
     if (perms & ReadOwnerPerm)
         mode |= S_IRUSR;
@@ -1169,18 +1180,27 @@ bool QFSFileEngine::setPermissions(uint perms)
     if (perms & ExeOtherPerm)
         mode |= S_IXOTH;
     if (d->fd != -1)
-        return !fchmod(d->fd, mode);
-    return !::chmod(d->nativeFilePath.constData(), mode);
+        ret = fchmod(d->fd, mode) == 0;
+    else
+        ret = ::chmod(d->nativeFilePath.constData(), mode) == 0;
+    if (!ret)
+        setError(QFile::PermissionsError, qt_error_string(errno));
+    return ret;
 }
 
 bool QFSFileEngine::setSize(qint64 size)
 {
     Q_D(QFSFileEngine);
+    bool ret = false;
     if (d->fd != -1)
-        return !QT_FTRUNCATE(d->fd, size);
-    if (d->fh)
-        return !QT_FTRUNCATE(QT_FILENO(d->fh), size);
-    return !QT_TRUNCATE(d->nativeFilePath.constData(), size);
+        ret = QT_FTRUNCATE(d->fd, size) == 0;
+    else if (d->fh)
+        ret = QT_FTRUNCATE(QT_FILENO(d->fh), size) == 0;
+    else
+        ret = QT_TRUNCATE(d->nativeFilePath.constData(), size) == 0;
+    if (!ret)
+        setError(QFile::ResizeError, qt_error_string(errno));
+    return ret;
 }
 
 QDateTime QFSFileEngine::fileTime(FileTime time) const
@@ -1202,14 +1222,14 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFla
 {
     Q_Q(QFSFileEngine);
     Q_UNUSED(flags);
-    if (offset < 0) {
-        q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
-        return 0;
-    }
     if (openMode == QIODevice::NotOpen) {
         q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
         return 0;
     }
+    if (offset < 0) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
+        return 0;
+    }
     int access = 0;
     if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
     if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index e01b42b..afe7b35 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -780,21 +780,30 @@ bool QFSFileEnginePrivate::nativeIsSequential() const
 bool QFSFileEngine::remove()
 {
     Q_D(QFSFileEngine);
-    return ::DeleteFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;
+    bool ret = ::DeleteFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;
+    if (!ret)
+        setError(QFile::RemoveError, qt_error_string());
+    return ret;
 }
 
 bool QFSFileEngine::copy(const QString &copyName)
 {
     Q_D(QFSFileEngine);
-    return ::CopyFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
-                      (wchar_t*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;
+    bool ret = ::CopyFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                          (wchar_t*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;
+    if (!ret)
+        setError(QFile::CopyError, qt_error_string());
+    return ret;
 }
 
 bool QFSFileEngine::rename(const QString &newName)
 {
     Q_D(QFSFileEngine);
-    return ::MoveFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
-                      (wchar_t*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;
+    bool ret = ::MoveFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                          (wchar_t*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;
+    if (!ret)
+        setError(QFile::RenameError, qt_error_string());
+    return ret;
 }
 
 static inline bool mkDir(const QString &path)
@@ -1303,6 +1312,9 @@ bool QFSFileEngine::link(const QString &newName)
         }
         psl->Release();
     }
+    if (!ret)
+        setError(QFile::RenameError, qt_error_string());
+
     if(neededCoInit)
             CoUninitialize();
 
@@ -1319,7 +1331,10 @@ bool QFSFileEngine::link(const QString &newName)
     // Need to append on our own
     orgName.prepend(QLatin1Char('"'));
     orgName.append(QLatin1Char('"'));
-    return SUCCEEDED(SHCreateShortcut((wchar_t*)linkName.utf16(), (wchar_t*)orgName.utf16()));
+    bool ret = SUCCEEDED(SHCreateShortcut((wchar_t*)linkName.utf16(), (wchar_t*)orgName.utf16()));
+    if (!ret)
+        setError(QFile::RenameError, qt_error_string());
+    return ret;
 #endif // Q_OS_WINCE
 }
 
@@ -1643,7 +1658,9 @@ bool QFSFileEngine::setPermissions(uint perms)
     if (mode == 0) // not supported
         return false;
 
-    ret = ::_wchmod((wchar_t*)d->longFileName(d->filePath).utf16(), mode) == 0;
+    ret = ::_wchmod((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(), mode) == 0;
+    if (!ret)
+        setError(QFile::PermissionsError, qt_error_string(errno));
     return ret;
 }
 
@@ -1675,7 +1692,10 @@ bool QFSFileEngine::setSize(qint64 size)
         // resize file on disk
         QFile file(d->filePath);
         if (file.open(QFile::ReadWrite)) {
-            return file.resize(size);
+            bool ret = file.resize(size);
+            if (!ret)
+                setError(QFile::ResizeError, file.errorString());
+            return ret;
         }
     }
     return false;
@@ -1778,11 +1798,11 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
     Q_Q(QFSFileEngine);
     Q_UNUSED(flags);
     if (openMode == QFile::NotOpen) {
-        q->setError(QFile::PermissionsError, qt_error_string());
+        q->setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED));
         return 0;
     }
     if (offset == 0 && size == 0) {
-        q->setError(QFile::UnspecifiedError, qt_error_string());
+        q->setError(QFile::UnspecifiedError, qt_error_string(ERROR_INVALID_PARAMETER));
         return 0;
     }
 
@@ -1864,7 +1884,7 @@ bool QFSFileEnginePrivate::unmap(uchar *ptr)
 {
     Q_Q(QFSFileEngine);
     if (!maps.contains(ptr)) {
-        q->setError(QFile::PermissionsError, qt_error_string());
+        q->setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED));
         return false;
     }
     uchar *start = ptr - maps[ptr].first;
diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
index 18ed676..057492d 100644
--- a/src/corelib/io/qprocess.cpp
+++ b/src/corelib/io/qprocess.cpp
@@ -101,27 +101,294 @@ QT_END_NAMESPACE
 
 QT_BEGIN_NAMESPACE
 
-static QHash<QString, QString> environmentHashFromList(const QStringList &environment)
+/*!
+    \class QProcessEnvironment
+
+    \brief The QProcessEnvironment class holds the environment variables that
+    can be passed to a program.
+
+    \ingroup io
+    \ingroup misc
+    \mainclass
+    \reentrant
+    \since 4.6
+
+    A process's environment is composed of a set of key=value pairs known as
+    environment variables. The QProcessEnvironment class wraps that concept
+    and allows easy manipulation of those variables. It's meant to be used
+    along with QProcess, to set the environment for child processes. It
+    cannot be used to change the current process's environment.
+
+    The environment of the calling process can be obtained using
+    QProcessEnvironment::systemEnvironment().
+
+    On Unix systems, the variable names are case-sensitive. For that reason,
+    this class will not touch the names of the variables. Note as well that
+    Unix environment allows both variable names and contents to contain arbitrary
+    binary data (except for the NUL character), but this is not supported by
+    QProcessEnvironment. This class only supports names and values that are
+    encodable by the current locale settings (see QTextCodec::codecForLocale).
+
+    On Windows, the variable names are case-insensitive. Therefore,
+    QProcessEnvironment will always uppercase the names and do case-insensitive
+    comparisons.
+
+    On Windows CE, the concept of environment does not exist. This class will
+    keep the values set for compatibility with other platforms, but the values
+    set will have no effect on the processes being created.
+
+    \sa QProcess, QProcess::systemEnvironment(), QProcess::setProcessEnvironment()
+*/
+#ifdef Q_OS_WIN
+static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
+{ return name.toUpper(); }
+static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
+{ return QString::fromLocal8Bit(name).toUpper(); }
+static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
+{ return name; }
+static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
+{ return value; }
+static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
+{ return QString::fromLocal8Bit(value); }
+static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
+{ return value; }
+static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
+{ return value.toLocal8Bit(); }
+#else
+static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
+{ return name; }
+static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
+{ return name.toLocal8Bit(); }
+static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
+{ return QString::fromLocal8Bit(name); }
+static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
+{ return value; }
+static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
+{ return value.toLocal8Bit(); }
+static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
+{ return QString::fromLocal8Bit(value); }
+static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
+{ return value; }
+#endif
+
+template<> void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
+{
+    if (d && d->ref == 1)
+        return;
+    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
+                                     : new QProcessEnvironmentPrivate);
+    x->ref.ref();
+    if (d && !d->ref.deref())
+        delete d;
+    d = x;
+}
+
+QStringList QProcessEnvironmentPrivate::toList() const
 {
-    QHash<QString, QString> result;
-    QStringList::ConstIterator it = environment.constBegin(),
-                              end = environment.constEnd();
+    QStringList result;
+    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
+                                    end = hash.constEnd();
     for ( ; it != end; ++it) {
-        int equals = it->indexOf(QLatin1Char('='));
+        QString data = nameToString(it.key());
+        QString value = valueToString(it.value());
+        data.reserve(data.length() + value.length() + 1);
+        data.append(QLatin1Char('='));
+        data.append(value);
+        result << data;
+    }
+    return result;
+}
 
+QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list)
+{
+    QProcessEnvironment env;
+    QStringList::ConstIterator it = list.constBegin(),
+                              end = list.constEnd();
+    for ( ; it != end; ++it) {
+        int pos = it->indexOf(QLatin1Char('='));
+        if (pos < 1)
+            continue;
+
+        QString value = it->mid(pos + 1);
         QString name = *it;
-        QString value;
-        if (equals != -1) {
-            name.truncate(equals);
-#ifdef Q_OS_WIN
-            name = name.toUpper();
-#endif
-            value = it->mid(equals + 1);
-        }
-        result.insert(name, value);
+        name.truncate(pos);
+        env.insert(name, value);
     }
+    return env;
+}
 
-    return result;
+/*!
+    Creates a new QProcessEnvironment object. This constructor creates an
+    empty environment. If set on a QProcess, this will cause the current
+    environment variables to be removed.
+*/
+QProcessEnvironment::QProcessEnvironment()
+    : d(0)
+{
+}
+
+/*!
+    Frees the resources associated with this QProcessEnvironment object.
+*/
+QProcessEnvironment::~QProcessEnvironment()
+{
+}
+
+/*!
+    Creates a QProcessEnvironment object that is a copy of \a other.
+*/
+QProcessEnvironment::QProcessEnvironment(const QProcessEnvironment &other)
+    : d(other.d)
+{
+}
+
+/*!
+    Copies the contents of the \a other QProcessEnvironment object into this
+    one.
+*/
+QProcessEnvironment &QProcessEnvironment::operator=(const QProcessEnvironment &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    \fn bool QProcessEnvironment::operator !=(const QProcessEnvironment &other) const
+
+    Returns true if this and the \a other QProcessEnvironment objects are different.
+
+    \sa operator==()
+*/
+
+/*!
+    Returns true if this and the \a other QProcessEnvironment objects are equal.
+
+    Two QProcessEnvironment objects are considered equal if they have the same
+    set of key=value pairs. The comparison of keys is done case-sensitive on
+    platforms where the environment is case-sensitive.
+
+    \sa operator!=(), contains()
+*/
+bool QProcessEnvironment::operator==(const QProcessEnvironment &other) const
+{
+    return d->hash == other.d->hash;
+}
+
+/*!
+    Returns true if this QProcessEnvironment object is empty: that is
+    there are no key=value pairs set.
+
+    \sa clear(), systemEnvironment(), insert()
+*/
+bool QProcessEnvironment::isEmpty() const
+{
+    return d ? d->hash.isEmpty() : true;
+}
+
+/*!
+    Removes all key=value pairs from this QProcessEnvironment object, making
+    it empty.
+
+    \sa isEmpty(), systemEnvironment()
+*/
+void QProcessEnvironment::clear()
+{
+    if (d)
+        d->hash.clear();
+}
+
+/*!
+    Returns true if the environment variable of name \a name is found in
+    this QProcessEnvironment object.
+
+    On Windows, variable names are case-insensitive, so the key is converted
+    to uppercase before searching. On other systems, names are case-sensitive
+    so no trasformation is applied.
+
+    \sa insert(), value()
+*/
+bool QProcessEnvironment::contains(const QString &name) const
+{
+    return d ? d->hash.contains(prepareName(name)) : false;
+}
+
+/*!
+    Inserts the environment variable of name \a name and contents \a value
+    into this QProcessEnvironment object. If that variable already existed,
+    it is replaced by the new value.
+
+    On Windows, variable names are case-insensitive, so this function always
+    uppercases the variable name before inserting. On other systems, names
+    are case-sensitive, so no transformation is applied.
+
+    On most systems, inserting a variable with no contents will have the
+    same effect for applications as if the variable had not been set at all.
+    However, to guarantee that there are no incompatibilities, to remove a
+    variable, please use the remove() function.
+
+    \sa contains(), remove(), value()
+*/
+void QProcessEnvironment::insert(const QString &name, const QString &value)
+{
+    d->hash.insert(prepareName(name), prepareValue(value));
+}
+
+/*!
+    Removes the environment variable identified by \a name from this
+    QProcessEnvironment object. If that variable did not exist before,
+    nothing happens.
+
+    On Windows, variable names are case-insensitive, so the key is converted
+    to uppercase before searching. On other systems, names are case-sensitive
+    so no trasformation is applied.
+
+    \sa contains(), insert(), value()
+*/
+void QProcessEnvironment::remove(const QString &name)
+{
+    if (d)
+        d->hash.remove(prepareName(name));
+}
+
+/*!
+    Searches this QProcessEnvironment object for a variable identified by
+    \a name and returns its value. If the variable is not found in this object,
+    then \a defaultValue is returned instead.
+
+    On Windows, variable names are case-insensitive, so the key is converted
+    to uppercase before searching. On other systems, names are case-sensitive
+    so no trasformation is applied.
+
+    \sa contains(), insert(), remove()
+*/
+QString QProcessEnvironment::value(const QString &name, const QString &defaultValue) const
+{
+    if (!d)
+        return defaultValue;
+
+    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(prepareName(name));
+    if (it == d->hash.constEnd())
+        return defaultValue;
+
+    return valueToString(it.value());
+}
+
+/*!
+    Converts this QProcessEnvironment object into a list of strings, one for
+    each environment variable that is set. The environment variable's name
+    and its value are separated by an equal character ('=').
+
+    The QStringList contents returned by this function are suitable for use
+    with the QProcess::setEnvironment function. However, it is recommended
+    to use QProcess::setProcessEnvironment instead since that will avoid
+    unnecessary copying of the data.
+
+    \sa systemEnvironment(), QProcess::systemEnvironment(), QProcess::environment(),
+        QProcess::setEnvironment()
+*/
+QStringList QProcessEnvironment::toStringList() const
+{
+    return d ? d->toList() : QStringList();
 }
 
 void QProcessPrivate::Channel::clear()
@@ -451,7 +718,6 @@ QProcessPrivate::QProcessPrivate()
     sequenceNumber = 0;
     exitCode = 0;
     exitStatus = QProcess::NormalExit;
-    environment = 0;
     startupSocketNotifier = 0;
     deathNotifier = 0;
     notifier = 0;
@@ -482,7 +748,6 @@ QProcessPrivate::QProcessPrivate()
 */
 QProcessPrivate::~QProcessPrivate()
 {
-    delete environment;
     if (stdinChannel.process)
         stdinChannel.process->stdoutChannel.clear();
     if (stdoutChannel.process)
@@ -1235,6 +1500,7 @@ QProcess::ProcessState QProcess::state() const
 }
 
 /*!
+    \deprecated
     Sets the environment that QProcess will use when starting a process to the
     \a environment specified which consists of a list of key=value pairs.
 
@@ -1243,14 +1509,18 @@ QProcess::ProcessState QProcess::state() const
 
     \snippet doc/src/snippets/qprocess-environment/main.cpp 0
 
-    \sa environment(), systemEnvironment(), setEnvironmentHash()
+    \note This function is less efficient than the setProcessEnvironment()
+    function.
+
+    \sa environment(), setProcessEnvironment(), systemEnvironment()
 */
 void QProcess::setEnvironment(const QStringList &environment)
 {
-    setEnvironmentHash(environmentHashFromList(environment));
+    setProcessEnvironment(QProcessEnvironmentPrivate::fromList(environment));
 }
 
 /*!
+    \deprecated
     Returns the environment that QProcess will use when starting a
     process, or an empty QStringList if no environment has been set
     using setEnvironment() or setEnvironmentHash(). If no environment
@@ -1259,67 +1529,50 @@ void QProcess::setEnvironment(const QStringList &environment)
     \note The environment settings are ignored on Windows CE and Symbian,
     as there is no concept of an environment.
 
-    \sa environmentHash(), setEnvironment(), systemEnvironment()
+    \sa processEnvironment(), setEnvironment(), systemEnvironment()
 */
 QStringList QProcess::environment() const
 {
     Q_D(const QProcess);
-
-    QStringList result;
-    if (!d->environment)
-        return result;
-
-    QHash<QString, QString>::ConstIterator it = d->environment->constBegin(),
-                                          end = d->environment->constEnd();
-    for ( ; it != end; ++it) {
-        QString data = it.key();
-        data.reserve(data.length() + it.value().length() + 1);
-        data.append(QLatin1Char('='));
-        data.append(it.value());
-        result << data;
-    }
-    return result;
+    return d->environment.toStringList();
 }
 
 /*!
-    \since 4.5
+    \since 4.6
     Sets the environment that QProcess will use when starting a process to the
-    \a environment hash map.
+    \a environment object.
 
     For example, the following code adds the \c{C:\\BIN} directory to the list of
     executable paths (\c{PATHS}) on Windows and sets \c{TMPDIR}:
 
     \snippet doc/src/snippets/qprocess-environment/main.cpp 1
 
-    \sa environment(), systemEnvironmentHash(), setEnvironment()
+    Note how, on Windows, environment variable names are case-insensitive.
+
+    \sa processEnvironment(), QProcessEnvironment::systemEnvironment(), setEnvironment()
 */
-void QProcess::setEnvironmentHash(const QHash<QString, QString> &environment)
+void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)
 {
     Q_D(QProcess);
-    if (!d->environment)
-        d->environment = new QHash<QString, QString>(environment);
-    else
-        *d->environment = environment;
+    d->environment = environment;
 }
 
 /*!
-    \since 4.5
+    \since 4.6
     Returns the environment that QProcess will use when starting a
-    process, or an empty QHash if no environment has been set using
-    setEnvironment() or setEnvironmentHash(). If no environment has
+    process, or an empty object if no environment has been set using
+    setEnvironment() or setProcessEnvironment(). If no environment has
     been set, the environment of the calling process will be used.
 
     \note The environment settings are ignored on Windows CE,
     as there is no concept of an environment.
 
-    \sa setEnvironmentHash(), setEnvironment(), systemEnvironmentHash()
+    \sa setProcessEnvironment(), setEnvironment(), QProcessEnvironment::isValid()
 */
-QHash<QString, QString> QProcess::environmentHash() const
+QProcessEnvironment QProcess::processEnvironment() const
 {
     Q_D(const QProcess);
-    if (d->environment)
-        return *d->environment;
-    return QHash<QString, QString>();
+    return d->environment;
 }
 
 /*!
@@ -1924,7 +2177,16 @@ QT_END_INCLUDE_NAMESPACE
 
     \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 8
 
-    \sa systemEnvironmentHash(), environment(), setEnvironment()
+    This function does not cache the system environment. Therefore, it's
+    possible to obtain an updated version of the environment if low-level C
+    library functions like \tt setenv ot \tt putenv have been called.
+
+    However, note that repeated calls to this function will recreate the
+    list of environment variables, which is a non-trivial operation.
+
+    \note For new code, it is recommended to use QProcessEvironment::systemEnvironment()
+
+    \sa QProcessEnvironment::systemEnvironment(), environment(), setEnvironment()
 */
 QStringList QProcess::systemEnvironment()
 {
@@ -1937,15 +2199,33 @@ QStringList QProcess::systemEnvironment()
 }
 
 /*!
-    \since 4.5
+    \since 4.6
+
+    Returns the environment of the calling process as a QProcessEnvironment.
 
-    Returns the environment of the calling process as a QHash.
+    This function does not cache the system environment. Therefore, it's
+    possible to obtain an updated version of the environment if low-level C
+    library functions like \tt setenv ot \tt putenv have been called.
 
-    \sa systemEnvironment(), environmentHash(), setEnvironmentHash()
+    However, note that repeated calls to this function will recreate the
+    QProcessEnvironment object, which is a non-trivial operation.
+
+    \sa QProcess::systemEnvironment()
 */
-QHash<QString, QString> QProcess::systemEnvironmentHash()
+QProcessEnvironment QProcessEnvironment::systemEnvironment()
 {
-    return environmentHashFromList(systemEnvironment());
+    QProcessEnvironment env;
+    const char *entry;
+    for (int count = 0; (entry = environ[count]); ++count) {
+        const char *equal = strchr(entry, '=');
+        if (!equal)
+            continue;
+
+        QByteArray name(entry, equal - entry);
+        QByteArray value(equal + 1);
+        env.insert(QString::fromLocal8Bit(name), QString::fromLocal8Bit(value));
+    }
+    return env;
 }
 
 /*!
diff --git a/src/corelib/io/qprocess.h b/src/corelib/io/qprocess.h
index 5faca5c..e0c7efb 100644
--- a/src/corelib/io/qprocess.h
+++ b/src/corelib/io/qprocess.h
@@ -44,6 +44,7 @@
 
 #include <QtCore/qiodevice.h>
 #include <QtCore/qstringlist.h>
+#include <QtCore/qshareddata.h>
 
 QT_BEGIN_HEADER
 
@@ -53,8 +54,6 @@ QT_MODULE(Core)
 
 #ifndef QT_NO_PROCESS
 
-template <class Key, class T> class QHash;
-
 #if (!defined(Q_OS_WIN32) && !defined(Q_OS_WINCE) && !defined(Q_OS_SYMBIAN)) || defined(qdoc)
 typedef qint64 Q_PID;
 #elif defined(Q_OS_SYMBIAN)
@@ -69,6 +68,37 @@ QT_BEGIN_NAMESPACE
 #endif
 
 class QProcessPrivate;
+class QProcessEnvironmentPrivate;
+
+class Q_CORE_EXPORT QProcessEnvironment
+{
+public:
+    QProcessEnvironment();
+    QProcessEnvironment(const QProcessEnvironment &other);
+    ~QProcessEnvironment();
+    QProcessEnvironment &operator=(const QProcessEnvironment &other);
+
+    bool operator==(const QProcessEnvironment &other) const;
+    inline bool operator!=(const QProcessEnvironment &other) const
+    { return !(*this == other); }
+
+    bool isEmpty() const;
+    void clear();
+
+    bool contains(const QString &name) const;
+    void insert(const QString &name, const QString &value);
+    void remove(const QString &name);
+    QString value(const QString &name, const QString &defaultValue = QString()) const;
+
+    QStringList toStringList() const;
+
+    static QProcessEnvironment systemEnvironment();
+
+private:
+    friend class QProcessPrivate;
+    friend class QProcessEnvironmentPrivate;
+    QSharedDataPointer<QProcessEnvironmentPrivate> d;
+};
 
 class Q_CORE_EXPORT QProcess : public QIODevice
 {
@@ -128,8 +158,8 @@ public:
 
     void setEnvironment(const QStringList &environment);
     QStringList environment() const;
-    void setEnvironmentHash(const QHash<QString, QString> &environment);
-    QHash<QString, QString> environmentHash() const;
+    void setProcessEnvironment(const QProcessEnvironment &environment);
+    QProcessEnvironment processEnvironment() const;
 
     QProcess::ProcessError error() const;
     QProcess::ProcessState state() const;
@@ -165,7 +195,6 @@ public:
     static bool startDetached(const QString &program);
 
     static QStringList systemEnvironment();
-    static QHash<QString, QString> systemEnvironmentHash();
 
 public Q_SLOTS:
     void terminate();
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
index 34797b9..62a2ecc 100644
--- a/src/corelib/io/qprocess_p.h
+++ b/src/corelib/io/qprocess_p.h
@@ -55,6 +55,8 @@
 
 #include "QtCore/qprocess.h"
 #include "QtCore/qstringlist.h"
+#include "QtCore/qhash.h"
+#include "QtCore/qshareddata.h"
 #include "private/qringbuffer_p.h"
 #include "private/qiodevice_p.h"
 
@@ -76,6 +78,21 @@ class QWindowsPipeWriter;
 class QWinEventNotifier;
 class QTimer;
 
+class QProcessEnvironmentPrivate: public QSharedData
+{
+public:
+#ifdef Q_OS_WIN
+    typedef QString Unit;
+#else
+    typedef QByteArray Unit;
+#endif
+    typedef QHash<Unit, Unit> Hash;
+    Hash hash;
+
+    static QProcessEnvironment fromList(const QStringList &list);
+    QStringList toList() const;
+};
+
 class QProcessPrivate : public QIODevicePrivate
 {
 public:
@@ -161,7 +178,7 @@ public:
 
     QString program;
     QStringList arguments;
-    QHash<QString, QString> *environment;
+    QProcessEnvironment environment;
 
     QRingBuffer outputReadBuffer;
     QRingBuffer errorReadBuffer;
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index d28cdc4..dfeeb71 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -458,11 +458,11 @@ bool QProcessPrivate::createChannel(Channel &channel)
     }
 }
 
-static char **_q_dupEnvironment(const QHash<QString, QString> *environment, int *envc)
+static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment, int *envc)
 {
     *envc = 0;
-    if (!environment)
-        return 0;               // use the default environment
+    if (environment.isEmpty())
+        return 0;
 
     // if LD_LIBRARY_PATH exists in the current environment, but
     // not in the environment list passed by the programmer, then
@@ -474,17 +474,17 @@ static char **_q_dupEnvironment(const QHash<QString, QString> *environment, int
 #endif
     const QByteArray envLibraryPath = qgetenv(libraryPath);
     bool needToAddLibraryPath = !envLibraryPath.isEmpty() &&
-                                !environment->contains(QLatin1String(libraryPath));
+                                !environment.contains(libraryPath);
 
-    char **envp = new char *[environment->count() + 2];
-    envp[environment->count()] = 0;
-    envp[environment->count() + 1] = 0;
+    char **envp = new char *[environment.count() + 2];
+    envp[environment.count()] = 0;
+    envp[environment.count() + 1] = 0;
 
-    QHash<QString, QString>::ConstIterator it = environment->constBegin();
-    const QHash<QString, QString>::ConstIterator end = environment->constEnd();
+    QHash<QByteArray, QByteArray>::ConstIterator it = environment.constBegin();
+    const QHash<QByteArray, QByteArray>::ConstIterator end = environment.constEnd();
     for ( ; it != end; ++it) {
-        QByteArray key = it.key().toLocal8Bit();
-        QByteArray value = it.value().toLocal8Bit();
+        QByteArray key = it.key();
+        QByteArray value = it.value();
         key.reserve(key.length() + 1 + value.length());
         key.append('=');
         key.append(value);
@@ -590,7 +590,9 @@ void QProcessPrivate::startProcess()
 
     // Duplicate the environment.
     int envc = 0;
-    char **envp = _q_dupEnvironment(environment, &envc);
+    char **envp = 0;
+    if (environment.d.constData())
+        envp = _q_dupEnvironment(environment.d.constData()->hash, &envc);
 
     // Encode the working directory if it's non-empty, otherwise just pass 0.
     const char *workingDirPtr = 0;
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
index acb169f..8ece6ec 100644
--- a/src/corelib/io/qprocess_win.cpp
+++ b/src/corelib/io/qprocess_win.cpp
@@ -278,17 +278,17 @@ static QString qt_create_commandline(const QString &program, const QStringList &
     return args;
 }
 
-static QByteArray qt_create_environment(const QHash<QString, QString> *environment)
+static QByteArray qt_create_environment(const QHash<QString, QString> &environment)
 {
     QByteArray envlist;
-    if (environment) {
-        QHash<QString, QString> copy = *environment;
+    if (!environment.isEmpty()) {
+        QHash<QString, QString> copy = environment;
 
         // add PATH if necessary (for DLL loading)
         if (!copy.contains(QLatin1String("PATH"))) {
             QByteArray path = qgetenv("PATH");
             if (!path.isEmpty())
-            copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
+                copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
         }
 
         // add systemroot if needed
@@ -362,7 +362,9 @@ void QProcessPrivate::startProcess()
     QString args = qt_create_commandline(QString(), arguments);
 #else
     QString args = qt_create_commandline(program, arguments);
-    QByteArray envlist = qt_create_environment(environment);
+    QByteArray envlist;
+    if (environment.d.constData())
+        envlist = qt_create_environment(environment.d.constData()->hash);
 #endif
 
 #if defined QPROCESS_DEBUG
@@ -393,9 +395,13 @@ void QProcessPrivate::startProcess()
     };
     success = CreateProcess(0, (wchar_t*)args.utf16(),
                             0, 0, TRUE, dwCreationFlags,
-                            environment ? envlist.data() : 0,
+                            environment.isEmpty() ? 0 : envlist.data(),
                             workingDirectory.isEmpty() ? 0 : (wchar_t*)QDir::toNativeSeparators(workingDirectory).utf16(),
                             &startupInfo, pid);
+    if (!success) {
+        // Capture the error string before we do CloseHandle below
+        q->setErrorString(QProcess::tr("Process failed to start: %1").arg(qt_error_string()));
+    }
 
     if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
         CloseHandle(stdinChannel.pipe[0]);
@@ -414,7 +420,6 @@ void QProcessPrivate::startProcess()
     if (!success) {
         cleanup();
         processError = QProcess::FailedToStart;
-        q->setErrorString(QProcess::tr("Process failed to start"));
         emit q->error(processError);
         q->setProcessState(QProcess::NotRunning);
         return;
diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp
index ab4a7b7..ff1a31f 100644
--- a/src/corelib/io/qresource.cpp
+++ b/src/corelib/io/qresource.cpp
@@ -1485,11 +1485,7 @@ uchar *QResourceFileEnginePrivate::map(qint64 offset, qint64 size, QFile::Memory
 {
     Q_Q(QResourceFileEngine);
     Q_UNUSED(flags);
-    if (!resource.isValid()
-        || offset < 0
-        || size < 0
-        || offset + size > resource.size()
-        || (size == 0)) {
+    if (offset < 0 || size <= 0 || !resource.isValid() || offset + size > resource.size()) {
         q->setError(QFile::UnspecifiedError, QString());
         return 0;
     }