Changeset 72

Timestamp:

Jul 9, 2009, 1:43:12 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: OS/2: Reimplemented QProcess using libc pipes (#7).

Location:

trunk/src/corelib/io

Files:

• io.pri (modified) (1 diff)
• qprocess.cpp (modified) (11 diffs)
• qprocess.h (modified) (1 diff)
• qprocess_os2.cpp (copied) (copied from trunk/src/corelib/io/qprocess_unix.cpp ) (28 diffs)
• qprocess_p.h (modified) (6 diffs)

trunk/src/corelib/io/io.pri ¶

@@ -62 +62 @@
 } else:os2 {
         SOURCES += io/qsettings_os2.cpp
-        # @todo later
-#        SOURCES += io/qprocess_os2.cpp
+        SOURCES += io/qprocess_os2.cpp
         SOURCES += io/qfsfileengine_os2.cpp
 

trunk/src/corelib/io/qprocess.cpp ¶

@@ -231 +231 @@
     \snippet doc/src/snippets/process/process.cpp 0
 
-    \section1 Notes for Windows Users
-
-    Some Windows commands (for example, \c dir) are not provided by
-    separate applications, but by the command interpreter itself.
+    \section1 Notes for Windows and OS/2 Users
+
+    Some Windows and OS/2 commands (for example, \c dir) are not provided
+    by separate applications, but by the command interpreter itself.
     If you attempt to use QProcess to execute these commands directly,
     it won't work. One possible solution is to execute the command
@@ -413 +413 @@
     processError = QProcess::UnknownError;
     processState = QProcess::NotRunning;
-#ifdef Q_OS_OS2
-    pid = PID_NULL;
-#else
     pid = 0;
-#endif
     sequenceNumber = 0;
     exitCode = 0;
@@ -458 +454 @@
 {
     q_func()->setProcessState(QProcess::NotRunning);
-#if !defined(Q_OS_OS2)
 #ifdef Q_OS_WIN
     if (pid) {
@@ -474 +469 @@
 #endif
     pid = 0;
-#else
-    pid = PID_NULL;
-#endif
     sequenceNumber = 0;
     dying = false;
 
-#if !defined(Q_OS_OS2)
     if (stdoutChannel.notifier) {
         stdoutChannel.notifier->setEnabled(false);
@@ -513 +504 @@
     destroyPipe(stderrChannel.pipe);
     destroyPipe(stdinChannel.pipe);
-#else
-    destroyPipe(stdoutChannel);
-    destroyPipe(stderrChannel);
-    destroyPipe(stdinChannel);
-#endif
-#if !defined(Q_OS_OS2)
     destroyPipe(childStartedPipe);
     destroyPipe(deathPipe);
-#endif
 #ifdef Q_OS_UNIX
     serial = 0;
@@ -534 +518 @@
     qint64 available = bytesAvailableFromStdout();
     if (available == 0) {
-#if !defined(Q_OS_OS2)
         if (stdoutChannel.notifier)
             stdoutChannel.notifier->setEnabled(false);
         destroyPipe(stdoutChannel.pipe);
-#else
-        destroyPipe(stdoutChannel);
-#endif
 #if defined QPROCESS_DEBUG
         qDebug("QProcessPrivate::canReadStandardOutput(), 0 bytes available");
@@ -593 +573 @@
     qint64 available = bytesAvailableFromStderr();
     if (available == 0) {
-#if !defined(Q_OS_OS2)
         if (stderrChannel.notifier)
             stderrChannel.notifier->setEnabled(false);
         destroyPipe(stderrChannel.pipe);
-#else
-        destroyPipe(stderrChannel);
-#endif
         return false;
     }
@@ -652 +628 @@
                                       writeBuffer.nextDataBlockSize());
     if (written < 0) {
-#if !defined(Q_OS_OS2)
         destroyPipe(stdinChannel.pipe);
-#else
-        destroyPipe(stdinChannel);
-#endif
         processError = QProcess::WriteError;
         q->setErrorString(QProcess::tr("Error writing to process"));
@@ -691 +663 @@
     qDebug("QProcessPrivate::_q_processDied()");
 #endif
-#ifdef Q_OS_UNIX
+#if defined(Q_OS_UNIX) || defined(Q_OS_OS2)
     if (!waitForDeadChild())
         return false;
@@ -801 +773 @@
     flushPipeWriter();
 #endif
-#if !defined(Q_OS_OS2)
     destroyPipe(stdinChannel.pipe);
-#else
-    destroyPipe(stdinChannel);
-#endif
 }
 
@@ -1107 +1075 @@
 /*!
     Returns the native process identifier for the running process, if
-    available.  If no process is currently running, 0 is returned on all
-    platforms except OS/2 which returns PID_NULL in this case.
+    available.  If no process is currently running, 0 is returned.
 */
 Q_PID QProcess::pid() const

trunk/src/corelib/io/qprocess.h ¶

@@ -57 +57 @@
 typedef qint64 Q_PID;
 #elif defined(Q_OS_OS2)
-typedef PID Q_PID;
-#define PID_NULL PID(~0)
+typedef int Q_PID;
 #else
 QT_END_NAMESPACE

trunk/src/corelib/io/qprocess_os2.cpp ¶

@@ -3 +3 @@
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** Copyright (C) 2009 netlabs.org. OS/2 parts.
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -86 +88 @@
 #include "qprocess_p.h"
 
-#ifdef Q_OS_MAC
-#include <private/qcore_mac_p.h>
-#endif
+#include <QtCore/qt_os2.h>
 
 #include <private/qcoreapplication_p.h>
@@ -100 +100 @@
 #include <qsemaphore.h>
 #include <qsocketnotifier.h>
-#include <qthread.h>
+#include <qdir.h>
 
 #include <errno.h>
-#include <stdlib.h>
-#include <string.h>
+#include <sys/filio.h>
 
 QT_BEGIN_NAMESPACE
 
-#ifdef Q_OS_INTEGRITY
-static inline char *strdup(const char *data)
-{
-    return qstrdup(data);
-}
-#endif
-
-static qint64 qt_native_read(int fd, char *data, qint64 maxlen)
-{
-    qint64 ret = 0;
-    do {
-        ret = ::read(fd, data, maxlen);
-    } while (ret == -1 && errno == EINTR);
-    return ret;
-}
-
-static qint64 qt_native_write(int fd, const char *data, qint64 len)
-{
-    qint64 ret = 0;
-    do {
-        ret = ::write(fd, data, len);
-    } while (ret == -1 && errno == EINTR);
-    return ret;
-}
-
-static void qt_native_close(int fd)
-{
-    int ret;
-    do {
-        ret = ::close(fd);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_sigaction(int signum, const struct sigaction *act,
-                                struct sigaction *oldact)
-{
-    int ret;
-    do {
-        ret = ::sigaction(signum, act, oldact);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_dup2(int oldfd, int newfd)
-{
-    int ret;
-    do {
-        ret = ::dup2(oldfd, newfd);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_chdir(const char *path)
-{
-    int ret;
-    do {
-        ret = ::chdir(path);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_execve(const char *filename, char *const argv[],
-                              char *const envp[])
-{
-    int ret;
-    do {
-        ret = ::execve(filename, argv, envp);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_execv(const char *path, char *const argv[])
-{
-    int ret;
-    do {
-        ret = ::execv(path, argv);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static void qt_native_execvp(const char *file, char *const argv[])
-{
-    int ret;
-    do {
-        ret = ::execvp(file, argv);
-    } while (ret == -1 && errno == EINTR);
-}
-
-static int qt_qprocess_deadChild_pipe[2];
-static void (*qt_sa_old_sigchld_handler)(int) = 0;
-static void qt_sa_sigchld_handler(int signum)
-{
-    qt_native_write(qt_qprocess_deadChild_pipe[1], "", 1);
-#if defined (QPROCESS_DEBUG)
-    fprintf(stderr, "*** SIGCHLD\n");
-#endif
-
-    if (qt_sa_old_sigchld_handler && qt_sa_old_sigchld_handler != SIG_IGN)
-        qt_sa_old_sigchld_handler(signum);
-}
-
-struct QProcessInfo {
-    QProcess *process;
-    int deathPipe;
-    int exitResult;
-    pid_t pid;
-    int serialNumber;
-};
-
-class QProcessManager : public QThread
-{
-    Q_OBJECT
-public:
-    QProcessManager();
-    ~QProcessManager();
-
-    void run();
-    void catchDeadChildren();
-    void add(pid_t pid, QProcess *process);
-    void remove(QProcess *process);
-    void lock();
-    void unlock();
-
-private:
-    QMutex mutex;
-    QMap<int, QProcessInfo *> children;
-};
-
-Q_GLOBAL_STATIC(QProcessManager, processManager)
-
-QProcessManager::QProcessManager()
-{
-#if defined (QPROCESS_DEBUG)
-    qDebug() << "QProcessManager::QProcessManager()";
-#endif
-    // initialize the dead child pipe and make it non-blocking. in the
-    // extremely unlikely event that the pipe fills up, we do not under any
-    // circumstances want to block.
-    ::pipe(qt_qprocess_deadChild_pipe);
-    ::fcntl(qt_qprocess_deadChild_pipe[0], F_SETFD, FD_CLOEXEC);
-    ::fcntl(qt_qprocess_deadChild_pipe[1], F_SETFD, FD_CLOEXEC);
-    ::fcntl(qt_qprocess_deadChild_pipe[0], F_SETFL,
-            ::fcntl(qt_qprocess_deadChild_pipe[0], F_GETFL) | O_NONBLOCK);
-    ::fcntl(qt_qprocess_deadChild_pipe[1], F_SETFL,
-            ::fcntl(qt_qprocess_deadChild_pipe[1], F_GETFL) | O_NONBLOCK);
-
-    // set up the SIGCHLD handler, which writes a single byte to the dead
-    // child pipe every time a child dies.
-    struct sigaction oldAction;
-    struct sigaction action;
-    memset(&action, 0, sizeof(action));
-    action.sa_handler = qt_sa_sigchld_handler;
-    action.sa_flags = SA_NOCLDSTOP;
-    qt_native_sigaction(SIGCHLD, &action, &oldAction);
-    if (oldAction.sa_handler != qt_sa_sigchld_handler)
-        qt_sa_old_sigchld_handler = oldAction.sa_handler;
-}
-
-QProcessManager::~QProcessManager()
-{
-    // notify the thread that we're shutting down.
-    qt_native_write(qt_qprocess_deadChild_pipe[1], "@", 1);
-    qt_native_close(qt_qprocess_deadChild_pipe[1]);
-    wait();
-
-    // on certain unixes, closing the reading end of the pipe will cause
-    // select in run() to block forever, rather than return with EBADF.
-    qt_native_close(qt_qprocess_deadChild_pipe[0]);
-
-    qt_qprocess_deadChild_pipe[0] = -1;
-    qt_qprocess_deadChild_pipe[1] = -1;
-
-    qDeleteAll(children.values());
-    children.clear();
-
-    struct sigaction oldAction;
-    struct sigaction action;
-    memset(&action, 0, sizeof(action));
-    action.sa_handler = qt_sa_old_sigchld_handler;
-    action.sa_flags = SA_NOCLDSTOP;
-    qt_native_sigaction(SIGCHLD, &action, &oldAction);
-    if (oldAction.sa_handler != qt_sa_sigchld_handler) {
-        qt_native_sigaction(SIGCHLD, &oldAction, 0);
-    }
-}
-
-void QProcessManager::run()
-{
-    forever {
-        fd_set readset;
-        FD_ZERO(&readset);
-        FD_SET(qt_qprocess_deadChild_pipe[0], &readset);
-
-#if defined (QPROCESS_DEBUG)
-        qDebug() << "QProcessManager::run() waiting for children to die";
-#endif
-
-        // block forever, or until activity is detected on the dead child
-        // pipe. the only other peers are the SIGCHLD signal handler, and the
-        // QProcessManager destructor.
-        int nselect = select(qt_qprocess_deadChild_pipe[0] + 1, &readset, 0, 0, 0);
-        if (nselect < 0) {
-            if (errno == EINTR)
-                continue;
-            break;
-        }
-
-        // empty only one byte from the pipe, even though several SIGCHLD
-        // signals may have been delivered in the meantime, to avoid race
-        // conditions.
-        char c;
-        if (qt_native_read(qt_qprocess_deadChild_pipe[0], &c, 1) < 0 || c == '@')
-            break;
-
-        // catch any and all children that we can.
-        catchDeadChildren();
-    }
-}
-
-void QProcessManager::catchDeadChildren()
-{
-    QMutexLocker locker(&mutex);
-
-    // try to catch all children whose pid we have registered, and whose
-    // deathPipe is still valid (i.e, we have not already notified it).
-    QMap<int, QProcessInfo *>::Iterator it = children.begin();
-    while (it != children.end()) {
-        // notify all children that they may have died. they need to run
-        // waitpid() in their own thread.
-        QProcessInfo *info = it.value();
-        qt_native_write(info->deathPipe, "", 1);
-
-#if defined (QPROCESS_DEBUG)
-        qDebug() << "QProcessManager::run() sending death notice to" << info->process;
-#endif
-        ++it;
-    }
-}
-
-static QBasicAtomicInt idCounter = Q_BASIC_ATOMIC_INITIALIZER(1);
-
-void QProcessManager::add(pid_t pid, QProcess *process)
-{
-#if defined (QPROCESS_DEBUG)
-    qDebug() << "QProcessManager::add() adding pid" << pid << "process" << process;
-#endif
-
-    // insert a new info structure for this process
-    QProcessInfo *info = new QProcessInfo;
-    info->process = process;
-    info->deathPipe = process->d_func()->deathPipe[1];
-    info->exitResult = 0;
-    info->pid = pid;
-
-    int serial = idCounter.fetchAndAddRelaxed(1);
-    process->d_func()->serial = serial;
-    children.insert(serial, info);
-}
-
-void QProcessManager::remove(QProcess *process)
-{
-    QMutexLocker locker(&mutex);
-
-    int serial = process->d_func()->serial;
-    QProcessInfo *info = children.value(serial);
-    if (!info)
-        return;
-
-#if defined (QPROCESS_DEBUG)
-    qDebug() << "QProcessManager::remove() removing pid" << info->pid << "process" << info->process;
-#endif
-
-    children.remove(serial);
-    delete info;
-}
-
-void QProcessManager::lock()
-{
-    mutex.lock();
-}
-
-void QProcessManager::unlock()
-{
-    mutex.unlock();
-}
-
 static void qt_create_pipe(int *pipe)
 {
     if (pipe[0] != -1)
-        qt_native_close(pipe[0]);
+        ::close(pipe[0]);
     if (pipe[1] != -1)
-        qt_native_close(pipe[1]);
-#ifdef Q_OS_IRIX
-    if (::socketpair(AF_UNIX, SOCK_STREAM, 0, pipe) == -1) {
-        qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
-                 pipe, qPrintable(qt_error_string(errno)));
-    }
-#else
+        ::close(pipe[1]);
     if (::pipe(pipe) != 0) {
         qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
                  pipe, qPrintable(qt_error_string(errno)));
     }
-#endif
     ::fcntl(pipe[0], F_SETFD, FD_CLOEXEC);
     ::fcntl(pipe[1], F_SETFD, FD_CLOEXEC);
@@ -413 +124 @@
 {
     if (pipe[1] != -1) {
-        qt_native_close(pipe[1]);
+        ::close(pipe[1]);
         pipe[1] = -1;
     }
     if (pipe[0] != -1) {
-        qt_native_close(pipe[0]);
+        ::close(pipe[0]);
         pipe[0] = -1;
     }
@@ -470 +181 @@
             // try to open in read-only mode
             channel.pipe[1] = -1;
-            if ( (channel.pipe[0] = QT_OPEN(fname, O_RDONLY)) != -1)
+            if ( (channel.pipe[0] = ::open(fname, O_RDONLY)) != -1)
                 return true;    // success
 
@@ -482 +193 @@
 
             channel.pipe[0] = -1;
-            if ( (channel.pipe[1] = QT_OPEN(fname, mode, 0666)) != -1)
+            if ( (channel.pipe[1] = ::open(fname, mode, 0666)) != -1)
                 return true; // success
 
@@ -532 +243 @@
 }
 
-static char **_q_dupEnvironment(const QStringList &environment, int *envc)
-{
-    // if LD_LIBRARY_PATH exists in the current environment, but
-    // not in the environment list passed by the programmer, then
-    // copy it over.
-#if defined(Q_OS_MAC)
-    static const char libraryPath[] = "DYLD_LIBRARY_PATH";
-#else
-    static const char libraryPath[] = "LD_LIBRARY_PATH";
-#endif
-    const QString libraryPathString = QLatin1String(libraryPath);
-    QStringList env = environment;
-    QStringList matches = env.filter(
-        QRegExp(QLatin1Char('^') + libraryPathString + QLatin1Char('=')));
-    const QString envLibraryPath = QString::fromLocal8Bit(::getenv(libraryPath));
-    if (matches.isEmpty() && !envLibraryPath.isEmpty()) {
-        QString entry = libraryPathString;
-        entry += QLatin1Char('=');
-        entry += envLibraryPath;
-        env << libraryPathString + QLatin1Char('=') + envLibraryPath;
-    }
-
-    char **envp = new char *[env.count() + 1];
-    envp[env.count()] = 0;
-
-    for (int j = 0; j < env.count(); ++j) {
-        QString item = env.at(j);
-        envp[j] = ::strdup(item.toLocal8Bit().constData());
-    }
-
-    *envc = env.count();
-    return envp;
-}
-
-// under QNX RTOS we have to use vfork() when multithreading
-inline pid_t qt_fork()
-{
-#if defined(Q_OS_QNX)
-    return vfork();
-#else
-    return fork();
-#endif
-}
-
-#ifdef Q_OS_MAC
-Q_GLOBAL_STATIC(QMutex, cfbundleMutex);
-#endif
-
 void QProcessPrivate::startProcess()
 {
@@ -588 +251 @@
 #endif
 
-    processManager()->start();
-
     // Initialize pipes
-    qt_create_pipe(childStartedPipe);
-    if (threadData->eventDispatcher) {
-        startupSocketNotifier = new QSocketNotifier(childStartedPipe[0],
-                                                    QSocketNotifier::Read, q);
-        QObject::connect(startupSocketNotifier, SIGNAL(activated(int)),
-                         q, SLOT(_q_startupNotification()));
-    }
-
-    qt_create_pipe(deathPipe);
-    ::fcntl(deathPipe[0], F_SETFD, FD_CLOEXEC);
-    ::fcntl(deathPipe[1], F_SETFD, FD_CLOEXEC);
-    if (threadData->eventDispatcher) {
-        deathNotifier = new QSocketNotifier(deathPipe[0],
-                                            QSocketNotifier::Read, q);
-        QObject::connect(deathNotifier, SIGNAL(activated(int)),
-                         q, SLOT(_q_processDied()));
-    }
-
     if (!createChannel(stdinChannel) ||
         !createChannel(stdoutChannel) ||
@@ -617 +260 @@
     q->setProcessState(QProcess::Starting);
 
+    // save & copy the stdin socket
+    int stdin_copy = ::dup(fileno(stdin));
+    ::dup2(stdinChannel.pipe[0], fileno(stdin));
+
+    // save & copy the stdout and stderr if asked to
+    int stdout_copy = -1, stderr_copy = -1;
+    if (processChannelMode != QProcess::ForwardedChannels) {
+        stdout_copy = ::dup(fileno(stdout));
+        ::dup2(stdoutChannel.pipe[1], fileno(stdout));
+
+        // merge stdout and stderr if asked to
+        stderr_copy = ::dup(fileno(stderr));
+        if (processChannelMode == QProcess::MergedChannels) {
+            ::dup2(fileno(stdout), fileno(stderr));
+        } else {
+            ::dup2(stderrChannel.pipe[1], fileno(stderr));
+        }
+    }
+
     // Create argument list with right number of elements, and set the final
     // one to 0.
@@ -624 +286 @@
     // Encode the program name.
     QByteArray encodedProgramName = QFile::encodeName(program);
-#ifdef Q_OS_MAC
-    // allow invoking of .app bundles on the Mac.
-    QFileInfo fileInfo(QString::fromUtf8(encodedProgramName.constData()));
-    if (encodedProgramName.endsWith(".app") && fileInfo.isDir()) {
-        QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0,
-                                                          QCFString(fileInfo.absoluteFilePath()),
-                                                          kCFURLPOSIXPathStyle, true);
-        {
-            // CFBundle is not reentrant, since CFBundleCreate might return a reference
-            // to a cached bundle object. Protect the bundle calls with a mutex lock.
-            QMutexLocker lock(cfbundleMutex());
-            QCFType<CFBundleRef> bundle = CFBundleCreate(0, url);
-            url = CFBundleCopyExecutableURL(bundle);
-        }
-        if (url) {
-            QCFString str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
-            encodedProgramName += "/Contents/MacOS/" + static_cast<QString>(str).toUtf8();
-        }
-    }
-#endif
 
     // Add the program name to the argument list.
-    char *dupProgramName = ::strdup(encodedProgramName.constData());
-    argv[0] = dupProgramName;
+    argv[0] = encodedProgramName.data();
 
     // Add every argument to the list
     for (int i = 0; i < arguments.count(); ++i) {
         QString arg = arguments.at(i);
-#ifdef Q_OS_MAC
-        // Mac OS X uses UTF8 for exec, regardless of the system locale.
-        argv[i + 1] = ::strdup(arg.toUtf8().constData());
-#else
-        argv[i + 1] = ::strdup(arg.toLocal8Bit().constData());
-#endif
+        argv[i + 1] = qstrdup(arg.toLocal8Bit().constData());
     }
 
     // Duplicate the environment.
     int envc = 0;
-    char **envp = _q_dupEnvironment(environment, &envc);
-
-    // Encode the working directory if it's non-empty, otherwise just pass 0.
-    const char *workingDirPtr = 0;
-    QByteArray encodedWorkingDirectory;
+    char **envv;
+    if (environment.count()) {
+        bool seenPATH = false;
+        bool seenCOMSPEC = false;
+
+        envv = new char *[environment.count() + 1 + 2 /* may be PATH + COMSPEC */];
+        for (; envc < environment.count(); ++envc) {
+            QString item = environment.at(envc);
+            envv[envc] = qstrdup(item.toLocal8Bit().constData());
+            if (!seenPATH)
+                seenPATH = !qstrncmp(envv[envc], "PATH=", 4);
+            if (!seenCOMSPEC)
+                seenCOMSPEC = !qstrncmp(envv[envc], "COMSPEC=", 8);
+        }
+        if (!seenPATH) {
+            // inherit PATH if missing (for convenience)
+            // (note that BEGINLIBPATH and ENDLIBPATH, if any, are automatically
+            // inherited, while LIBPATH is always a global setting)
+            QByteArray path = qgetenv("PATH");
+            path.prepend("PATH=");
+            envv[envc++] = qstrdup(path);
+        }
+        // inherit COMSPEC if missing (to let the child start .cmd and .bat)
+        if (!seenCOMSPEC) {
+            QByteArray comspec = qgetenv("COMSPEC");
+            comspec.prepend("COMSPEC=");
+            envv[envc++] = qstrdup(comspec);
+        }
+        envv[envc] = 0;
+    } else {
+        // inherit the parent environment
+        envv = environ;
+    }
+
+    // Set the working directory if it's non-empty
+    QString curDir;
     if (!workingDirectory.isEmpty()) {
-        encodedWorkingDirectory = QFile::encodeName(workingDirectory);
-        workingDirPtr = encodedWorkingDirectory.constData();
-    }
-
-    // If the program does not specify a path, generate a list of possible
-    // locations for the binary using the PATH environment variable.
-    char **path = 0;
-    int pathc = 0;
-    if (!program.contains(QLatin1Char('/'))) {
-        const QString pathEnv = QString::fromLocal8Bit(::getenv("PATH"));
-        if (!pathEnv.isEmpty()) {
-            QStringList pathEntries = pathEnv.split(QLatin1Char(':'), QString::SkipEmptyParts);
-            if (!pathEntries.isEmpty()) {
-                pathc = pathEntries.size();
-                path = new char *[pathc + 1];
-                path[pathc] = 0;
-
-                for (int k = 0; k < pathEntries.size(); ++k) {
-                    QByteArray tmp = QFile::encodeName(pathEntries.at(k));
-                    if (!tmp.endsWith('/')) tmp += '/';
-                    tmp += encodedProgramName;
-                    path[k] = ::strdup(tmp.constData());
-                }
-            }
-        }
-    }
-
-    // Start the process manager, and fork off the child process.
-    processManager()->lock();
-    pid_t childPid = qt_fork();
-    int lastForkErrno = errno;
-    if (childPid != 0) {
-        // Clean up duplicated memory.
-        free(dupProgramName);
-        for (int i = 1; i <= arguments.count(); ++i)
-            free(argv[i]);
+        curDir = QDir::currentPath();
+        QDir::setCurrent(workingDirectory);
+    }
+
+    // start the program
+    int pid = spawnvpe(P_NOWAIT | P_DEFAULT, encodedProgramName, argv, envv);
+
+    // if spawnvpe() couldn't find the executable, try .CMD and .BAT
+    // extensions (in order of CMD.EXE precedence); spawnvpe() knows how to
+    // locate and run them (i.e. using CMD.EXE /c)
+    if ( pid == -1 && errno == ENOENT ) {
+        encodedProgramName += ".cmd";
+        argv[0] = encodedProgramName.data();
+        pid = spawnvpe(P_NOWAIT | P_DEFAULT, encodedProgramName, argv, envv);
+        if ( pid == -1 && errno == ENOENT ) {
+            qstrcpy(encodedProgramName.data() + encodedProgramName.length() - 4, ".bat");
+            argv[0] = encodedProgramName.data();
+            pid = spawnvpe(P_NOWAIT | P_DEFAULT, encodedProgramName, argv, envv);
+        }
+    }
+
+    // Clean up duplicated memory.
+    for (int i = 1 /* 0 is encodedProgramName */; i <= arguments.count(); ++i)
+        delete [] argv[i];
+    delete [] argv;
+    if (envv != environ) {
         for (int i = 0; i < envc; ++i)
-            free(envp[i]);
-        for (int i = 0; i < pathc; ++i)
-            free(path[i]);
-        delete [] argv;
-        delete [] envp;
-        delete [] path;
-    }
-    if (childPid < 0) {
+            delete [] envv[i];
+        delete [] envv;
+    }
+
+    // restore the current directory
+    QDir::setCurrent(curDir);
+
+    // restore stdin/stdout/stderr
+    if (stdin_copy != -1) {
+        ::dup2(stdin_copy, fileno(stdin));
+        ::close(stdin_copy);
+    }
+    if (stdout_copy != -1) {
+        ::dup2(stdout_copy, fileno(stdout));
+        ::close(stdout_copy);
+    }
+    if (stderr_copy != -1) {
+        ::dup2(stderr_copy, fileno(stderr));
+        ::close(stderr_copy);
+    }
+
+    if (pid == -1) {
         // Cleanup, report error and return
 #if defined (QPROCESS_DEBUG)
-        qDebug("qt_fork failed: %s", qt_error_string(lastForkErrno));
-#endif
-        processManager()->unlock();
+        qDebug("spawnvpe failed: %s", qt_error_string(errno));
+#endif
         q->setProcessState(QProcess::NotRunning);
         processError = QProcess::FailedToStart;
-        q->setErrorString(QProcess::tr("Resource error (fork failure): %1").arg(qt_error_string(lastForkErrno)));
+        q->setErrorString(QProcess::tr("Process failed to start: %1").arg(qt_error_string(errno)));
         emit q->error(processError);
         cleanup();
@@ -726 +396 @@
     }
 
-    // Start the child.
-    if (childPid == 0) {
-        execChild(workingDirPtr, path, argv, envp);
-        ::_exit(-1);
-    }
-
-    // Register the child. In the mean time, we can get a SIGCHLD, so we need
-    // to keep the lock held to avoid a race to catch the child.
-    processManager()->add(childPid, q);
-    pid = Q_PID(childPid);
-    processManager()->unlock();
-
-    // parent
+    this->pid = Q_PID(pid);
+
     // close the ends we don't use and make all pipes non-blocking
-    ::fcntl(deathPipe[0], F_SETFL, ::fcntl(deathPipe[0], F_GETFL) | O_NONBLOCK);
-    qt_native_close(childStartedPipe[1]);
-    childStartedPipe[1] = -1;
-
     if (stdinChannel.pipe[0] != -1) {
-        qt_native_close(stdinChannel.pipe[0]);
+        ::close(stdinChannel.pipe[0]);
         stdinChannel.pipe[0] = -1;
     }
-
     if (stdinChannel.pipe[1] != -1)
         ::fcntl(stdinChannel.pipe[1], F_SETFL, ::fcntl(stdinChannel.pipe[1], F_GETFL) | O_NONBLOCK);
 
     if (stdoutChannel.pipe[1] != -1) {
-        qt_native_close(stdoutChannel.pipe[1]);
+        ::close(stdoutChannel.pipe[1]);
         stdoutChannel.pipe[1] = -1;
     }
-
     if (stdoutChannel.pipe[0] != -1)
         ::fcntl(stdoutChannel.pipe[0], F_SETFL, ::fcntl(stdoutChannel.pipe[0], F_GETFL) | O_NONBLOCK);
 
     if (stderrChannel.pipe[1] != -1) {
-        qt_native_close(stderrChannel.pipe[1]);
+        ::close(stderrChannel.pipe[1]);
         stderrChannel.pipe[1] = -1;
     }
     if (stderrChannel.pipe[0] != -1)
         ::fcntl(stderrChannel.pipe[0], F_SETFL, ::fcntl(stderrChannel.pipe[0], F_GETFL) | O_NONBLOCK);
-}
-
-void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv, char **envp)
-{
-    ::signal(SIGPIPE, SIG_DFL);         // reset the signal that we ignored
-
-    Q_Q(QProcess);
-
-    // copy the stdin socket
-    qt_native_dup2(stdinChannel.pipe[0], fileno(stdin));
-
-    // copy the stdout and stderr if asked to
-    if (processChannelMode != QProcess::ForwardedChannels) {
-        qt_native_dup2(stdoutChannel.pipe[1], fileno(stdout));
-
-        // merge stdout and stderr if asked to
-        if (processChannelMode == QProcess::MergedChannels) {
-            qt_native_dup2(fileno(stdout), fileno(stderr));
-        } else {
-            qt_native_dup2(stderrChannel.pipe[1], fileno(stderr));
-        }
-    }
-
-    // make sure this fd is closed if execvp() succeeds
-    qt_native_close(childStartedPipe[0]);
-    ::fcntl(childStartedPipe[1], F_SETFD, FD_CLOEXEC);
-
-    // enter the working directory
-    if (workingDir)
-        qt_native_chdir(workingDir);
-
-    // this is a virtual call, and it base behavior is to do nothing.
-    q->setupChildProcess();
-
-    // execute the process
-    if (environment.isEmpty()) {
-        qt_native_execvp(argv[0], argv);
-    } else {
-        if (path) {
-            char **arg = path;
-            while (*arg) {
-                argv[0] = *arg;
-#if defined (QPROCESS_DEBUG)
-                fprintf(stderr, "QProcessPrivate::execChild() searching / starting %s\n", argv[0]);
-#endif
-                qt_native_execve(argv[0], argv, envp);
-                ++arg;
-            }
-        } else {
-#if defined (QPROCESS_DEBUG)
-            fprintf(stderr, "QProcessPrivate::execChild() starting %s\n", argv[0]);
-#endif
-            qt_native_execve(argv[0], argv, envp);
-        }
-    }
-
-    // notify failure
-#if defined (QPROCESS_DEBUG)
-    fprintf(stderr, "QProcessPrivate::execChild() failed, notifying parent process\n");
-#endif
-    qt_native_write(childStartedPipe[1], "", 1);
-    qt_native_close(childStartedPipe[1]);
-    childStartedPipe[1] = -1;
+
+    q->setProcessState(QProcess::Running);
+    // User can call kill()/terminate() from the stateChanged() slot
+    // so check before proceeding
+    if (!pid)
+        return;
+
+    // give the process a chance to start ...
+    DosSleep(100);
+    _q_startupNotification();
 }
 
 bool QProcessPrivate::processStarted()
 {
-    char c;
-    int i = qt_native_read(childStartedPipe[0], &c, 1);
-    if (startupSocketNotifier) {
-        startupSocketNotifier->setEnabled(false);
-        startupSocketNotifier->deleteLater();
-        startupSocketNotifier = 0;
-    }
-    qt_native_close(childStartedPipe[0]);
-    childStartedPipe[0] = -1;
-
-#if defined (QPROCESS_DEBUG)
-    qDebug("QProcessPrivate::processStarted() == %s", i <= 0 ? "true" : "false");
-#endif
-    return i <= 0;
+    return processState == QProcess::Running;
 }
 
@@ -875 +462 @@
 qint64 QProcessPrivate::readFromStdout(char *data, qint64 maxlen)
 {
-    qint64 bytesRead = qt_native_read(stdoutChannel.pipe[0], data, maxlen);
+    qint64 bytesRead = ::read(stdoutChannel.pipe[0], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStdout(%p \"%s\", %lld) == %lld",
@@ -885 +472 @@
 qint64 QProcessPrivate::readFromStderr(char *data, qint64 maxlen)
 {
-    qint64 bytesRead = qt_native_read(stderrChannel.pipe[0], data, maxlen);
+    qint64 bytesRead = ::read(stderrChannel.pipe[0], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::readFromStderr(%p \"%s\", %lld) == %lld",
@@ -893 +480 @@
 }
 
-static void qt_ignore_sigpipe()
-{
-    // Set to ignore SIGPIPE once only.
-    static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);
-    if (atom.testAndSetRelaxed(0, 1)) {
-        struct sigaction noaction;
-        memset(&noaction, 0, sizeof(noaction));
-        noaction.sa_handler = SIG_IGN;
-        qt_native_sigaction(SIGPIPE, &noaction, 0);
-    }
-}
-
 qint64 QProcessPrivate::writeToStdin(const char *data, qint64 maxlen)
 {
-    qt_ignore_sigpipe();
-
-    qint64 written = qt_native_write(stdinChannel.pipe[1], data, maxlen);
+    qint64 written = ::write(stdinChannel.pipe[1], data, maxlen);
 #if defined QPROCESS_DEBUG
     qDebug("QProcessPrivate::writeToStdin(%p \"%s\", %lld) == %lld",
@@ -920 +493 @@
 {
 #if defined (QPROCESS_DEBUG)
-    qDebug("QProcessPrivate::killProcess()");
-#endif
-    if (pid)
-        ::kill(pid_t(pid), SIGTERM);
+    qDebug("QProcessPrivate::terminateProcess()");
+#endif
+    if (pid) {
+        HSWITCH hswitch = WinQuerySwitchHandle(NULL, pid);
+        if (hswitch != NULLHANDLE) {
+            SWCNTRL swcntrl = { 0 };
+            APIRET rc = WinQuerySwitchEntry(hswitch,  &swcntrl);
+            // WinQuerySwitchEntry will return a switch entry of the parent
+            // process if the specfied one doesn't have a separate session
+            // (running a plain CMD.EXE is an example); ignore this case.
+            if (rc == NO_ERROR && swcntrl.idProcess == pid)
+            {
+                // first, ensure that the Close action is enabled in the main frame
+                // window (otherwise WM_SYSCOMMAND/SC_CLOSE will be ignored)
+                HWND hwndSysMenu = WinWindowFromID(swcntrl.hwnd, FID_SYSMENU);
+                if (hwndSysMenu) {
+                    WinPostMsg(hwndSysMenu, MM_SETITEMATTR,
+                               MPFROM2SHORT(SC_CLOSE, TRUE),
+                               MPFROM2SHORT(MIA_DISABLED, 0));
+                }
+                WinPostMsg(swcntrl.hwnd, WM_SYSCOMMAND,
+                           MPFROM2SHORT(SC_CLOSE, CMDSRC_OTHER),
+                           MPFROMLONG(FALSE));
+            }
+        }
+    }
 }
 
@@ -932 +527 @@
 #endif
     if (pid)
-        ::kill(pid_t(pid), SIGKILL);
-}
-
-static int qt_native_select(fd_set *fdread, fd_set *fdwrite, int timeout)
-{
-    struct timeval tv;
-    tv.tv_sec = timeout / 1000;
-    tv.tv_usec = (timeout % 1000) * 1000;
-
-    int ret;
-    do {
-        ret = select(FD_SETSIZE, fdread, fdwrite, 0, timeout < 0 ? 0 : &tv);
-    } while (ret < 0 && (errno == EINTR));
-    return ret;
+        DosKillProcess(DKP_PROCESS, pid);
 }
 
@@ -961 +543 @@
 }
 
+static int qt_select(fd_set *fdread, fd_set *fdwrite, int timeout)
+{
+    struct timeval tv;
+    tv.tv_sec = timeout / 1000;
+    tv.tv_usec = (timeout % 1000) * 1000;
+
+    int ret = select(FD_SETSIZE, fdread, fdwrite, 0, timeout < 0 ? 0 : &tv);
+    return ret;
+}
+
 bool QProcessPrivate::waitForStarted(int msecs)
 {
     Q_Q(QProcess);
 
-#if defined (QPROCESS_DEBUG)
-    qDebug("QProcessPrivate::waitForStarted(%d) waiting for child to start (fd = %d)", msecs,
-           childStartedPipe[0]);
-#endif
-
-    fd_set fds;
-    FD_ZERO(&fds);
-    FD_SET(childStartedPipe[0], &fds);
-    int ret;
-    do {
-        ret = qt_native_select(&fds, 0, msecs);
-    } while (ret < 0 && errno == EINTR);
-    if (ret == 0) {
-        processError = QProcess::Timedout;
-        q->setErrorString(QProcess::tr("Process operation timed out"));
-#if defined (QPROCESS_DEBUG)
-        qDebug("QProcessPrivate::waitForStarted(%d) == false (timed out)", msecs);
-#endif
+    if (processStarted())
+        return true;
+
+    if (processError == QProcess::FailedToStart)
         return false;
-    }
-
-    bool startedEmitted = _q_startupNotification();
-#if defined (QPROCESS_DEBUG)
-    qDebug("QProcessPrivate::waitForStarted() == %s", startedEmitted ? "true" : "false");
-#endif
-    return startedEmitted;
+
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
 }
 
@@ -1009 +584 @@
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
-
-        if (processState == QProcess::Starting)
-            FD_SET(childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
@@ -1018 +590 @@
             FD_SET(stderrChannel.pipe[0], &fdread);
 
-        FD_SET(deathPipe[0], &fdread);
-
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             FD_SET(stdinChannel.pipe[1], &fdwrite);
 
         int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-        int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        int ret = qt_select(&fdread, &fdwrite, timeout);
         if (ret < 0) {
-            if (errno == EINTR)
-                continue;
             break;
         }
@@ -1033 +601 @@
             processError = QProcess::Timedout;
             q->setErrorString(QProcess::tr("Process operation timed out"));
-            return false;
-        }
-
-        if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
-            if (!_q_startupNotification())
-                return false;
-        }
+            return false;
+        }
 
         bool readyReadEmitted = false;
-        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
-            bool canRead = _q_canReadStandardOutput();
+        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
+            bool canRead = _q_canReadStandardOutput();
             if (processChannel == QProcess::StandardOutput && canRead)
                 readyReadEmitted = true;
-        }
-        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread)) {
-            bool canRead = _q_canReadStandardError();
+        }
+        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread)) {
+            bool canRead = _q_canReadStandardError();
             if (processChannel == QProcess::StandardError && canRead)
                 readyReadEmitted = true;
-        }
+        }
         if (readyReadEmitted)
             return true;
 
-        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-            _q_canWrite();
-
-        if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
-            if (_q_processDied())
-                return false;
-        }
+        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+            _q_canWrite();
+
+        if (!pid)
+            return false;
+        if (_q_processDied())
+            return false;
     }
     return false;
@@ -1082 +645 @@
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
-
-        if (processState == QProcess::Starting)
-            FD_SET(childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
@@ -1091 +651 @@
             FD_SET(stderrChannel.pipe[0], &fdread);
 
-        FD_SET(deathPipe[0], &fdread);
-
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             FD_SET(stdinChannel.pipe[1], &fdwrite);
 
-        int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-        int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
+        int ret = qt_select(&fdread, &fdwrite, timeout);
         if (ret < 0) {
-            if (errno == EINTR)
-                continue;
             break;
         }
-
         if (ret == 0) {
-            processError = QProcess::Timedout;
-            q->setErrorString(QProcess::tr("Process operation timed out"));
-            return false;
-        }
-
-        if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
-            if (!_q_startupNotification())
-                return false;
-        }
-
-        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-            return _q_canWrite();
-
-        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
-            _q_canReadStandardOutput();
-
-        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
-            _q_canReadStandardError();
-
-        if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
-            if (_q_processDied())
-                return false;
-        }
+            processError = QProcess::Timedout;
+            q->setErrorString(QProcess::tr("Process operation timed out"));
+            return false;
+        }
+
+        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+            return _q_canWrite();
+
+        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
+            _q_canReadStandardOutput();
+
+        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
+            _q_canReadStandardError();
+
+        if (!pid)
+            return false;
+        if (_q_processDied())
+            return false;
     }
 
@@ -1149 +699 @@
         FD_ZERO(&fdread);
         FD_ZERO(&fdwrite);
-
-        if (processState == QProcess::Starting)
-            FD_SET(childStartedPipe[0], &fdread);
 
         if (stdoutChannel.pipe[0] != -1)
@@ -1158 +705 @@
             FD_SET(stderrChannel.pipe[0], &fdread);
 
-        if (processState == QProcess::Running)
-            FD_SET(deathPipe[0], &fdread);
-
         if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
             FD_SET(stdinChannel.pipe[1], &fdwrite);
 
-        int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
-        int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
+        int ret = qt_select(&fdread, &fdwrite, timeout);
         if (ret < 0) {
-            if (errno == EINTR)
-                continue;
             break;
         }
-        if (ret == 0) {
-            processError = QProcess::Timedout;
-            q->setErrorString(QProcess::tr("Process operation timed out"));
-            return false;
-        }
-
-        if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
-            if (!_q_startupNotification())
-                return false;
-        }
-        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
-            _q_canWrite();
-
-        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
-            _q_canReadStandardOutput();
-
-        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
-            _q_canReadStandardError();
-
-        if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
-            if (_q_processDied())
-                return true;
-        }
+        if (ret == 0) {
+            processError = QProcess::Timedout;
+            q->setErrorString(QProcess::tr("Process operation timed out"));
+            return false;
+        }
+
+        if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+            _q_canWrite();
+
+        if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
+            _q_canReadStandardOutput();
+
+        if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
+            _q_canReadStandardError();
+
+        if (!pid)
+            return true;
+        if (_q_processDied())
+            return true;
     }
     return false;
@@ -1204 +742 @@
     FD_SET(stdinChannel.pipe[1], &fdwrite);
 
-    int ret;
-    do {
-        ret = qt_native_select(0, &fdwrite, msecs < 0 ? 0 : msecs) == 1;
-    } while (ret < 0 && errno == EINTR);
+    int ret = qt_select(0, &fdwrite, msecs < 0 ? 0 : msecs) == 1;
     return ret == 1;
 }
@@ -1213 +748 @@
 void QProcessPrivate::findExitCode()
 {
-    Q_Q(QProcess);
-    processManager()->remove(q);
 }
 
 bool QProcessPrivate::waitForDeadChild()
 {
-    Q_Q(QProcess);
-
-    // read a byte from the death pipe
-    char c;
-    qt_native_read(deathPipe[0], &c, 1);
-
     // check if our process is dead
     int exitStatus;
-    pid_t waitResult = 0;
-    do {
-        waitResult = waitpid(pid_t(pid), &exitStatus, WNOHANG);
-    } while ((waitResult == -1 && errno == EINTR));
+    pid_t waitResult = waitpid(pid, &exitStatus, WNOHANG);
     if (waitResult > 0) {
-        processManager()->remove(q);
         crashed = !WIFEXITED(exitStatus);
         exitCode = WEXITSTATUS(exitStatus);
@@ -1255 +778 @@
 bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid)
 {
+// @todo later
+#if 0
     processManager()->start();
 
@@ -1367 +892 @@
     qt_native_close(pidPipe[0]);
     return success;
-}
-
-void QProcessPrivate::initializeProcessManager()
-{
-    (void) processManager();
+#endif
 }
 
 QT_END_NAMESPACE
 
-#include "qprocess_unix.moc"
-
 #endif // QT_NO_PROCESS

trunk/src/corelib/io/qprocess_p.h ¶

@@ -59 +59 @@
 #include "private/qiodevice_p.h"
 
-#if defined(Q_OS_WIN)
+#ifdef Q_OS_WIN
 #include "QtCore/qt_windows.h"
 typedef HANDLE Q_PIPE;
 #define INVALID_Q_PIPE INVALID_HANDLE_VALUE
-#elif defined(Q_OS_OS2)
-#include "QtCore/qt_os2.h"
-#define HP_NULL HPIPE(~0)
-#define HF_NULL HFILE(~0)
 #else
 typedef int Q_PIPE;
@@ -97 +93 @@
         Channel() : process(0), notifier(0), type(Normal), closed(false), append(false)
         {
-#if !defined(Q_OS_OS2)
             pipe[0] = INVALID_Q_PIPE;
             pipe[1] = INVALID_Q_PIPE;
-#else
-            pipe = HP_NULL;
-            file = HF_NULL;
-#endif
         }
 
@@ -132 +123 @@
         QString file;
         QProcessPrivate *process;
-#if !defined(Q_OS_OS2)
         QSocketNotifier *notifier;
         Q_PIPE pipe[2];
-#else
-        HPIPE pipe;
-        HFILE file;
-#endif
 
         unsigned type : 2;
@@ -182 +168 @@
     QRingBuffer writeBuffer;
 
-#if !defined(Q_OS_OS2)
     Q_PIPE childStartedPipe[2];
     Q_PIPE deathPipe[2];
@@ -194 +179 @@
     QWindowsPipeWriter *pipeWriter;
     QWinEventNotifier *processFinishedNotifier;
-#else
-    void destroyPipe(Channel &channel);
-#endif
 
     void startProcess();
@@ -206 +188 @@
     void killProcess();
     void findExitCode();
-#ifdef Q_OS_UNIX
+#if defined(Q_OS_UNIX) || defined(Q_OS_OS2)
     bool waitForDeadChild();
 #endif