Changeset 71 for trunk/src

Timestamp:

Jul 7, 2009, 1:49:11 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: OS/2: Partly implemented QProcess using native pipes (#7).

Location:

trunk/src/corelib/io

Files:

• qprocess.cpp (modified) (11 diffs)
• qprocess.h (modified) (1 diff)
• qprocess_os2.cpp (copied) (copied from trunk/src/corelib/io/qprocess_win.cpp ) (11 diffs)
• qprocess_p.h (modified) (5 diffs)

trunk/src/corelib/io/qprocess.cpp

@@ -231 +231 @@
     \snippet doc/src/snippets/process/process.cpp 0
 
-    \section1 Notes for Windows Users 
+    \section1 Notes for Windows Users
 
     Some Windows commands (for example, \c dir) are not provided by
@@ -413 +413 @@
     processError = QProcess::UnknownError;
     processState = QProcess::NotRunning;
+#ifdef Q_OS_OS2
+    pid = PID_NULL;
+#else
     pid = 0;
+#endif
     sequenceNumber = 0;
     exitCode = 0;
@@ -454 +458 @@
 {
     q_func()->setProcessState(QProcess::NotRunning);
+#if !defined(Q_OS_OS2)
 #ifdef Q_OS_WIN
     if (pid) {
@@ -469 +474 @@
 #endif
     pid = 0;
+#else
+    pid = PID_NULL;
+#endif
     sequenceNumber = 0;
     dying = false;
 
+#if !defined(Q_OS_OS2)
     if (stdoutChannel.notifier) {
         stdoutChannel.notifier->setEnabled(false);
@@ -504 +513 @@
     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;
@@ -518 +534 @@
     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");
@@ -573 +593 @@
     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;
     }
@@ -628 +652 @@
                                       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"));
@@ -766 +794 @@
             qDeleteInEventHandler(stdinChannel.notifier);
             stdinChannel.notifier = 0;
-        } 
+        }
     }
 #ifdef Q_OS_WIN
@@ -773 +801 @@
     flushPipeWriter();
 #endif
+#if !defined(Q_OS_OS2)
     destroyPipe(stdinChannel.pipe);
+#else
+    destroyPipe(stdinChannel);
+#endif
 }
 
@@ -1075 +1107 @@
 /*!
     Returns the native process identifier for the running process, if
-    available.  If no process is currently running, 0 is returned.
+    available.  If no process is currently running, 0 is returned on all
+    platforms except OS/2 which returns PID_NULL in this case.
 */
 Q_PID QProcess::pid() const

trunk/src/corelib/io/qprocess.h

@@ -56 +56 @@
 #if (!defined(Q_OS_WIN32) && !defined(Q_OS_WINCE)) || defined(qdoc)
 typedef qint64 Q_PID;
+#elif defined(Q_OS_OS2)
+typedef PID Q_PID;
+#define PID_NULL PID(~0)
 #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.
@@ -42 +44 @@
 #include "qprocess.h"
 #include "qprocess_p.h"
-#include "qwindowspipewriter_p.h"
-
-#include <qdatetime.h>
-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qtimer.h>
-#include <qthread.h>
-#include <qmutex.h>
-#include <qwaitcondition.h>
-#include <private/qwineventnotifier_p.h>
-#include <private/qthread_p.h>
-#include <qdebug.h>
-
-#include "private/qfsfileengine_p.h" // for longFileName and win95FileName
+// @todo need?
+//#include "qwindowspipewriter_p.h"
+
+// @todo need what?
+//#include <qdatetime.h>
+//#include <qdir.h>
+//#include <qfileinfo.h>
+//#include <qtimer.h>
+//#include <qthread.h>
+//#include <qmutex.h>
+//#include <qwaitcondition.h>
+//#include <private/qthread_p.h>
+//#include <qdebug.h>
 
 
@@ -64 +65 @@
 //#define QPROCESS_DEBUG
 
-#define NOTIFYTIMEOUT 100
-
-static void qt_create_pipe(Q_PIPE *pipe, bool in)
-{
-    // Open the pipes.  Make non-inheritable copies of input write and output
-    // read handles to avoid non-closable handles (this is done by the
-    // DuplicateHandle() call).
-
-#if !defined(Q_OS_WINCE)
-    SECURITY_ATTRIBUTES secAtt = { sizeof( SECURITY_ATTRIBUTES ), NULL, TRUE };
-
-    HANDLE tmpHandle;
-    if (in) {                   // stdin
-        if (!CreatePipe(&pipe[0], &tmpHandle, &secAtt, 1024 * 1024))
-            return;
-        if (!DuplicateHandle(GetCurrentProcess(), tmpHandle, GetCurrentProcess(),
-                             &pipe[1], 0, FALSE, DUPLICATE_SAME_ACCESS))
-            return;
-    } else {                    // stdout or stderr
-        if (!CreatePipe(&tmpHandle, &pipe[1], &secAtt, 1024 * 1024))
-            return;
-        if (!DuplicateHandle(GetCurrentProcess(), tmpHandle, GetCurrentProcess(),
-                             &pipe[0], 0, FALSE, DUPLICATE_SAME_ACCESS))
-            return;
-    }
-
-    CloseHandle(tmpHandle);
-#else
-        Q_UNUSED(pipe);
-        Q_UNUSED(in);
-#endif
-}
+// @todo need?
+//#define NOTIFYTIMEOUT 100
+
+enum
+{
+    PIPE_SIZE_STDIN = 65520, // max
+    PIPE_SIZE_STDOUT = 65520, // max
+    PIPE_SIZE_STDERR = 4096,
+
+// @todo need?
+//  POLL_TIMER = 100,
+//
+//  // new pipe data notification
+//  WM_U_PIPE_RDATA = WM_USER + 0,
+//  WM_U_PIPE_CLOSE = WM_USER + 1,
+};
 
 /*
@@ -107 +92 @@
 
     if (&channel == &stderrChannel && processChannelMode == QProcess::MergedChannels) {
-        return DuplicateHandle(GetCurrentProcess(), stdoutChannel.pipe[1], GetCurrentProcess(),
-                               &stderrChannel.pipe[1], 0, TRUE, DUPLICATE_SAME_ACCESS);
-    }
+        // we will make a stdout to stderr redirection upon process startup
+        channel.pipe = HP_NULL;
+        channel.file = HF_NULL;
+        return true;
+    }
+
+    // we need the process identifier to guarantee pipe name unicity
+    PPIB ppib = NULL;
+    DosGetInfoBlocks(NULL, &ppib);
+
+    APIRET rc = 0;
+    char pathBuf[CCHMAXPATH];
 
     if (channel.type == Channel::Normal) {
-        // we're piping this channel to our own process
-        qt_create_pipe(channel.pipe, &channel == &stdinChannel);
+        const char *name;
+        ULONG pipeMode;
+        ULONG outBufSize;
+        ULONG inBufSize;
+        ULONG fileMode;
+        if (&channel == &stdinChannel) {
+            name = "Stdin";
+            pipeMode = NP_ACCESS_OUTBOUND;
+            outBufSize = PIPE_SIZE_STDIN;
+            inBufSize = 0;
+            fileMode = OPEN_ACCESS_READONLY;
+        } else if (&channel == &stdoutChannel) {
+            name = "Stdout";
+            pipeMode = NP_ACCESS_INBOUND;
+            outBufSize = 0;
+            inBufSize = PIPE_SIZE_STDOUT;
+            fileMode = OPEN_ACCESS_WRITEONLY;
+        } else if (&channel == &stderrChannel) {
+            name = "Stderr";
+            pipeMode = NP_ACCESS_INBOUND;
+            outBufSize = 0;
+            inBufSize = PIPE_SIZE_STDERR;
+            fileMode = OPEN_ACCESS_WRITEONLY;
+        } else {
+            Q_ASSERT(false);
+            return false;
+        }
+
+        sprintf(pathBuf, "\\pipe\\Qt\\%08lX\\QProcess\\%p\\%s",
+                ppib->pib_ulpid, name, this);
+        rc = DosCreateNPipe(pathBuf, &channel.pipe,
+                            pipeMode | NP_NOINHERIT, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                            outBufSize, inBufSize, 0);
+        if (rc != NO_ERROR) {
+            qWarning("QProcessPrivate::createChannel: DosCreateNPipe(%s) "
+                     "returned %lu", pathBuf, rc);
+            return false;
+        }
+        DosConnectNPipe(channel.pipe);
+
+        // open the client end of the pipe
+        ULONG action = 0;
+        rc = DosOpen(pathBuf, &channel.file, &action, 0, FILE_NORMAL, FILE_OPEN,
+                     fileMode | OPEN_SHARE_DENYREADWRITE | OPEN_FLAGS_NOINHERIT,
+                     (PEAOP2) NULL);
+        if (rc != NO_ERROR) {
+            qWarning("QProcessPrivate::createChannel: DosOpen(%s) "
+                     "returned %lu", pathBuf, rc);
+            return false;
+        }
 
         return true;
     } else if (channel.type == Channel::Redirect) {
         // we're redirecting the channel to/from a file
-        SECURITY_ATTRIBUTES secAtt = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
+        channel.pipe = HP_NULL;
+        QByteArray fname = QFile::encodeName(channel.file);
+        ULONG action = 0;
 
         if (&channel == &stdinChannel) {
-            // try to open in read-only mode
-            channel.pipe[1] = INVALID_Q_PIPE;
-            QT_WA({
-                channel.pipe[0] =
-                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
-                                GENERIC_READ,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                OPEN_EXISTING,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            }, {
-                channel.pipe[0] =
-                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
-                                GENERIC_READ,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                OPEN_EXISTING,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            });
-            if (channel.pipe[0] != INVALID_Q_PIPE)
+            // open in read-only mode
+            rc = DosOpen(fname, &channel.file, &action, 0, FILE_NORMAL, FILE_OPEN,
+                         OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_NOINHERIT,
+                         (PEAOP2) NULL);
+            if (rc == NO_ERROR)
                 return true;
 
@@ -148 +175 @@
         } else {
             // open in write mode
-            channel.pipe[0] = INVALID_Q_PIPE;
-            DWORD creation;
-            if (channel.append)
-                creation = OPEN_ALWAYS;
-            else
-                creation = CREATE_ALWAYS;
-
-            QT_WA({
-                channel.pipe[1] =
-                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
-                                GENERIC_WRITE,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                creation,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            }, {
-                channel.pipe[1] =
-                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
-                                GENERIC_WRITE,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                creation,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            });
-            if (channel.pipe[1] != INVALID_Q_PIPE) {
+            ULONG flags = channel.append ? FILE_OPEN : FILE_CREATE;
+            rc = DosOpen(fname, &channel.file, &action, 0, FILE_NORMAL,
+                         channel.append ? FILE_OPEN : FILE_CREATE,
+                         OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_NOINHERIT,
+                         (PEAOP2) NULL);
+            if (rc == NO_ERROR) {
                 if (channel.append) {
-                    SetFilePointer(channel.pipe[1], 0, NULL, FILE_END);
+                    ULONG actual;
+                    DosSetFilePtr(channel.file, 0, &actual);
                 }
                 return true;
@@ -200 +207 @@
             sink = &channel.process->stdinChannel;
 
-            if (source->pipe[1] != INVALID_Q_PIPE) {
-                // already constructed by the sink
-                // make it inheritable
-                HANDLE tmpHandle = source->pipe[1];
-                if (!DuplicateHandle(GetCurrentProcess(), tmpHandle,
-                                     GetCurrentProcess(), &source->pipe[1],
-                                     0, TRUE, DUPLICATE_SAME_ACCESS))
-                    return false;
-
-                CloseHandle(tmpHandle);
-                return true;
-            }
-
             Q_ASSERT(source == &stdoutChannel);
             Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
-
-            qt_create_pipe(source->pipe, /* in = */ false); // source is stdout
-            sink->pipe[0] = source->pipe[0];
-            source->pipe[0] = INVALID_Q_PIPE;
-
-            return true;
         } else {
             // we are the sink;
@@ -226 +214 @@
             sink = &channel;
 
-            if (sink->pipe[0] != INVALID_Q_PIPE) {
-                // already constructed by the source
-                // make it inheritable
-                HANDLE tmpHandle = sink->pipe[0];
-                if (!DuplicateHandle(GetCurrentProcess(), tmpHandle,
-                                     GetCurrentProcess(), &sink->pipe[0],
-                                     0, TRUE, DUPLICATE_SAME_ACCESS))
-                    return false;
-
-                CloseHandle(tmpHandle);
-                return true;
-            }
             Q_ASSERT(sink == &stdinChannel);
             Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
-
-            qt_create_pipe(sink->pipe, /* in = */ true); // sink is stdin
-            source->pipe[1] = sink->pipe[1];
-            sink->pipe[1] = INVALID_Q_PIPE;
-
+        }
+
+        if (source->pipe != HP_NULL && sink->file != HF_NULL) {
+            // already created, do nothing
+            Q_ASSERT(sink->pipe == HP_NULL && source->file == HF_NULL);
             return true;
-        }
-    }
-}
-
-void QProcessPrivate::destroyPipe(Q_PIPE pipe[2])
-{
-    if (pipe[0] == stdinChannel.pipe[0] && pipe[1] == stdinChannel.pipe[1] && pipeWriter) {
-        delete pipeWriter;
-        pipeWriter = 0;
-    }
-
-    if (pipe[0] != INVALID_Q_PIPE) {
-        CloseHandle(pipe[0]);
-        pipe[0] = INVALID_Q_PIPE;
-    }
-    if (pipe[1] != INVALID_Q_PIPE) {
-        CloseHandle(pipe[1]);
-        pipe[1] = INVALID_Q_PIPE;
-    }
-}
-
-
-static QString qt_create_commandline(const QString &program, const QStringList &arguments)
-{
-    QString args;
-    if (!program.isEmpty()) {
-        QString programName = program;
-        if (!programName.startsWith(QLatin1Char('\"')) && !programName.endsWith(QLatin1Char('\"')) && programName.contains(QLatin1String(" ")))
-            programName = QLatin1String("\"") + programName + QLatin1String("\"");
-        programName.replace(QLatin1String("/"), QLatin1String("\\"));
-
-        // add the prgram as the first arg ... it works better
-        args = programName + QLatin1String(" ");
-    }
-
-    for (int i=0; i<arguments.size(); ++i) {
-        QString tmp = arguments.at(i);
-        // in the case of \" already being in the string the \ must also be escaped
-        tmp.replace( QLatin1String("\\\""), QLatin1String("\\\\\"") );
-        // escape a single " because the arguments will be parsed
-        tmp.replace( QLatin1String("\""), QLatin1String("\\\"") );
-        if (tmp.isEmpty() || tmp.contains(QLatin1Char(' ')) || tmp.contains(QLatin1Char('\t'))) {
-            // The argument must not end with a \ since this would be interpreted
-            // as escaping the quote -- rather put the \ behind the quote: e.g.
-            // rather use "foo"\ than "foo\"
-            QString endQuote(QLatin1String("\""));
-            int i = tmp.length();
-            while (i>0 && tmp.at(i-1) == QLatin1Char('\\')) {
-                --i;
-                endQuote += QLatin1String("\\");
+        } else {
+            // create a single pipe for both processes (source will get its handle)
+            Q_ASSERT(source->pipe == HP_NULL && source->file == HF_NULL);
+            Q_ASSERT(sink->pipe == HP_NULL && sink->file == HF_NULL);
+
+            sprintf(pathBuf, "\\pipe\\Qt\\%08lX\\QProcess\\%p\\SinkTo\\%p",
+                    ppib->pib_ulpid, sink->process, source->process);
+            rc = DosCreateNPipe(pathBuf, &source->pipe,
+                                NP_ACCESS_OUTBOUND | NP_NOINHERIT, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                                PIPE_SIZE_STDOUT, 0, 0);
+            if (rc != NO_ERROR) {
+                qWarning("QProcessPrivate::createChannel: DosCreateNPipe(%s) "
+                         "returned %lu", pathBuf, rc);
+                return false;
             }
-            args += QLatin1String(" \"") + tmp.left(i) + endQuote;
-        } else {
-            args += QLatin1Char(' ') + tmp;
-        }
-    }
-    return args;
-}
-
-static QByteArray qt_create_environment(const QStringList &environment)
-{
-    QByteArray envlist;
-    if (!environment.isEmpty()) {
-        QStringList envStrings = environment;
-            int pos = 0;
-            // add PATH if necessary (for DLL loading)
-        if (envStrings.filter(QRegExp(QLatin1String("^PATH="),Qt::CaseInsensitive)).isEmpty()) {
-            QByteArray path = qgetenv("PATH");
-            if (!path.isEmpty())
-                envStrings.prepend(QString(QLatin1String("PATH=%1")).arg(QString::fromLocal8Bit(path)));
-        }
-        // add systemroot if needed
-        if (envStrings.filter(QRegExp(QLatin1String("^SystemRoot="),Qt::CaseInsensitive)).isEmpty()) {
-            QByteArray systemRoot = qgetenv("SystemRoot");
-            if (!systemRoot.isEmpty())
-                envStrings.prepend(QString(QLatin1String("SystemRoot=%1")).arg(QString::fromLocal8Bit(systemRoot)));
-        }
-#ifdef UNICODE
-        if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
-            for (QStringList::ConstIterator it = envStrings.constBegin(); it != envStrings.constEnd(); ++it) {
-                QString tmp = *it;
-                uint tmpSize = sizeof(TCHAR) * (tmp.length()+1);
-                envlist.resize(envlist.size() + tmpSize);
-                memcpy(envlist.data()+pos, tmp.utf16(), tmpSize);
-                pos += tmpSize;
-                }
-                // add the 2 terminating 0 (actually 4, just to be on the safe side)
-                envlist.resize( envlist.size()+4 );
-                envlist[pos++] = 0;
-                envlist[pos++] = 0;
-                envlist[pos++] = 0;
-                envlist[pos++] = 0;
-        } else
-#endif // UNICODE
-        {
-            for (QStringList::ConstIterator it = envStrings.constBegin(); it != envStrings.constEnd(); it++) {
-                QByteArray tmp = (*it).toLocal8Bit();
-                uint tmpSize = tmp.length() + 1;
-                envlist.resize(envlist.size() + tmpSize);
-                memcpy(envlist.data()+pos, tmp.data(), tmpSize);
-                pos += tmpSize;
+            DosConnectNPipe(source->pipe);
+
+            // open the client end of the pipe that sink will get
+            ULONG action = 0;
+            rc = DosOpen(pathBuf, &sink->file, &action, 0, FILE_NORMAL, FILE_OPEN,
+                         OPEN_ACCESS_READONLY | OPEN_SHARE_DENYREADWRITE | OPEN_FLAGS_NOINHERIT,
+                         (PEAOP2) NULL);
+            if (rc != NO_ERROR) {
+                qWarning("QProcessPrivate::createChannel: DosOpen(%s) "
+                         "returned %lu", pathBuf, rc);
+                return false;
             }
-            // add the terminating 0 (actually 2, just to be on the safe side)
-            envlist.resize(envlist.size()+2);
-            envlist[pos++] = 0;
-            envlist[pos++] = 0;
-        }
-    }
-    return envlist;
-}
+
+            source->file = HF_NULL;
+            sink->pipe = HP_NULL;
+            return true;
+        }
+    }
+}
+
+void QProcessPrivate::destroyPipe(QProcessPrivate::Channel &channel)
+{
+    if (channel.file != HF_NULL) {
+        DosClose(channel.file);
+        channel.file = HP_NULL;
+    }
+
+    if (channel.pipe != HP_NULL) {
+        DosDisConnectPipe(channel.pipe);
+        DosClose(channel.pipe);
+        channel.pipe = HP_NULL;
+    }
+}
+
+// @todo need?
+//static QString qt_create_commandline(const QString &program, const QStringList &arguments)
+//{
+//    QString args;
+//    if (!program.isEmpty()) {
+//        QString programName = program;
+//        if (!programName.startsWith(QLatin1Char('\"')) && !programName.endsWith(QLatin1Char('\"')) && programName.contains(QLatin1String(" ")))
+//            programName = QLatin1String("\"") + programName + QLatin1String("\"");
+//        programName.replace(QLatin1String("/"), QLatin1String("\\"));
+//
+//        // add the prgram as the first arg ... it works better
+//        args = programName + QLatin1String(" ");
+//    }
+//
+//    for (int i=0; i<arguments.size(); ++i) {
+//        QString tmp = arguments.at(i);
+//        // in the case of \" already being in the string the \ must also be escaped
+//        tmp.replace( QLatin1String("\\\""), QLatin1String("\\\\\"") );
+//        // escape a single " because the arguments will be parsed
+//        tmp.replace( QLatin1String("\""), QLatin1String("\\\"") );
+//        if (tmp.isEmpty() || tmp.contains(QLatin1Char(' ')) || tmp.contains(QLatin1Char('\t'))) {
+//            // The argument must not end with a \ since this would be interpreted
+//            // as escaping the quote -- rather put the \ behind the quote: e.g.
+//            // rather use "foo"\ than "foo\"
+//            QString endQuote(QLatin1String("\""));
+//            int i = tmp.length();
+//            while (i>0 && tmp.at(i-1) == QLatin1Char('\\')) {
+//                --i;
+//                endQuote += QLatin1String("\\");
+//            }
+//            args += QLatin1String(" \"") + tmp.left(i) + endQuote;
+//        } else {
+//            args += QLatin1Char(' ') + tmp;
+//        }
+//    }
+//    return args;
+//}
+//
+//static QByteArray qt_create_environment(const QStringList &environment)
+//{
+//    QByteArray envlist;
+//    if (!environment.isEmpty()) {
+//        QStringList envStrings = environment;
+//        int pos = 0;
+//        // add PATH if necessary (for DLL loading)
+//        if (envStrings.filter(QRegExp(QLatin1String("^PATH="),Qt::CaseInsensitive)).isEmpty()) {
+//            QByteArray path = qgetenv("PATH");
+//            if (!path.isEmpty())
+//                envStrings.prepend(QString(QLatin1String("PATH=%1")).arg(QString::fromLocal8Bit(path)));
+//        }
+//        // add systemroot if needed
+//        if (envStrings.filter(QRegExp(QLatin1String("^SystemRoot="),Qt::CaseInsensitive)).isEmpty()) {
+//            QByteArray systemRoot = qgetenv("SystemRoot");
+//            if (!systemRoot.isEmpty())
+//                envStrings.prepend(QString(QLatin1String("SystemRoot=%1")).arg(QString::fromLocal8Bit(systemRoot)));
+//        }
+//#ifdef UNICODE
+//        if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
+//            for (QStringList::ConstIterator it = envStrings.constBegin(); it != envStrings.constEnd(); ++it) {
+//                QString tmp = *it;
+//                uint tmpSize = sizeof(TCHAR) * (tmp.length()+1);
+//                envlist.resize(envlist.size() + tmpSize);
+//                memcpy(envlist.data()+pos, tmp.utf16(), tmpSize);
+//                pos += tmpSize;
+//            }
+//            // add the 2 terminating 0 (actually 4, just to be on the safe side)
+//            envlist.resize( envlist.size()+4 );
+//            envlist[pos++] = 0;
+//            envlist[pos++] = 0;
+//            envlist[pos++] = 0;
+//            envlist[pos++] = 0;
+//        } else
+//#endif // UNICODE
+//        {
+//            for (QStringList::ConstIterator it = envStrings.constBegin(); it != envStrings.constEnd(); it++) {
+//                QByteArray tmp = (*it).toLocal8Bit();
+//                uint tmpSize = tmp.length() + 1;
+//                envlist.resize(envlist.size() + tmpSize);
+//                memcpy(envlist.data()+pos, tmp.data(), tmpSize);
+//                pos += tmpSize;
+//            }
+//            // add the terminating 0 (actually 2, just to be on the safe side)
+//            envlist.resize(envlist.size()+2);
+//            envlist[pos++] = 0;
+//            envlist[pos++] = 0;
+//        }
+//    }
+//    return envlist;
+//}
 
 void QProcessPrivate::startProcess()
@@ -362 +366 @@
 
     bool success = false;
-
-    if (pid) {
-        CloseHandle(pid->hThread);
-        CloseHandle(pid->hProcess);
-        delete pid;
-        pid = 0;
-    }
-    pid = new PROCESS_INFORMATION;
-    memset(pid, 0, sizeof(PROCESS_INFORMATION));
 
     q->setProcessState(QProcess::Starting);
@@ -379 +374 @@
         return;
 
-#if defined(Q_OS_WINCE)
-    QString args = qt_create_commandline(QString(), arguments);
-#else
-    QString args = qt_create_commandline(program, arguments);
-    QByteArray envlist = qt_create_environment(environment);
-#endif
-
-#if defined QPROCESS_DEBUG
-    qDebug("Creating process");
-    qDebug("   program : [%s]", program.toLatin1().constData());
-    qDebug("   args : %s", args.toLatin1().constData());
-    qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
-#endif
-
-    DWORD dwCreationFlags = 0;
-    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based))
-        dwCreationFlags |= CREATE_NO_WINDOW;
-
-#ifdef UNICODE
-    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
-#if defined(Q_OS_WINCE)
-        QString fullPathProgram = program;
-        if (!QDir::isAbsolutePath(fullPathProgram))
-            fullPathProgram = QFileInfo(fullPathProgram).absoluteFilePath();
-        fullPathProgram.replace(QLatin1String("/"), QLatin1String("\\"));
-        success = CreateProcessW((WCHAR*)fullPathProgram.utf16(),
-                                 (WCHAR*)args.utf16(),
-                                 0, 0, false, 0, 0, 0, 0, pid);
-#else
-        dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
-        STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         0, 0, 0,
-                                         STARTF_USESTDHANDLES,
-                                         0, 0, 0,
-                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
-        };
-        success = CreateProcessW(0, (WCHAR*)args.utf16(),
-                                 0, 0, TRUE, dwCreationFlags,
-                                 environment.isEmpty() ? 0 : envlist.data(),
-                                 workingDirectory.isEmpty() ? 0
-                                    : (WCHAR*)QDir::toNativeSeparators(workingDirectory).utf16(),
-                                 &startupInfo, pid);
-#endif
-    } else
-#endif // UNICODE
-    {
-#ifndef Q_OS_WINCE
-            STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         0, 0, 0,
-                                         STARTF_USESTDHANDLES,
-                                         0, 0, 0,
-                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
-            };
-
-            success = CreateProcessA(0, args.toLocal8Bit().data(),
-                                     0, 0, TRUE, dwCreationFlags, environment.isEmpty() ? 0 : envlist.data(),
-                                     workingDirectory.isEmpty() ? 0
-                                        : QDir::toNativeSeparators(workingDirectory).toLocal8Bit().data(),
-                                     &startupInfo, pid);
-#endif // Q_OS_WINCE
-    }
-#ifndef Q_OS_WINCE
-    if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
-        CloseHandle(stdinChannel.pipe[0]);
-        stdinChannel.pipe[0] = INVALID_Q_PIPE;
-    }
-    if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) {
-        CloseHandle(stdoutChannel.pipe[1]);
-        stdoutChannel.pipe[1] = INVALID_Q_PIPE;
-    }
-    if (stderrChannel.pipe[1] != INVALID_Q_PIPE) {
-        CloseHandle(stderrChannel.pipe[1]);
-        stderrChannel.pipe[1] = INVALID_Q_PIPE;
-    }
-#endif // Q_OS_WINCE
+// @todo remove
+//#if defined(Q_OS_WINCE)
+//    QString args = qt_create_commandline(QString(), arguments);
+//#else
+//    QString args = qt_create_commandline(program, arguments);
+//    QByteArray envlist = qt_create_environment(environment);
+//#endif
+//
+//#if defined QPROCESS_DEBUG
+//    qDebug("Creating process");
+//    qDebug("   program : [%s]", program.toLatin1().constData());
+//    qDebug("   args : %s", args.toLatin1().constData());
+//    qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
+//#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
 
     if (!success) {
@@ -470 +413 @@
     q->setProcessState(QProcess::Running);
     // User can call kill()/terminate() from the stateChanged() slot
-    // so check before proceeding 
-    if (!pid) 
+    // so check before proceeding
+    if (pid == PID_NULL)
         return;
 
-    if (threadData->eventDispatcher) {
-        processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
-        QObject::connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_processDied()));
-        processFinishedNotifier->setEnabled(true);
-        notifier = new QTimer(q);
-        QObject::connect(notifier, SIGNAL(timeout()), q, SLOT(_q_notified()));
-        notifier->start(NOTIFYTIMEOUT);
-    }
-
-    // give the process a chance to start ...
-    Sleep(SLEEPMIN*2);
+// @todo check this
     _q_startupNotification();
 }
@@ -875 +808 @@
                                    };
         success = CreateProcessW(0, (WCHAR*)args.utf16(),
-                                 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, 0, 
+                                 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, 0,
                                  workingDir.isEmpty() ? (const WCHAR *)0 : (const WCHAR *)workingDir.utf16(),
                                  &startupInfo, &pinfo);

trunk/src/corelib/io/qprocess_p.h

@@ -59 +59 @@
 #include "private/qiodevice_p.h"
 
-#ifdef Q_OS_WIN
+#if defined(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;
@@ -93 +97 @@
         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
         }
 
@@ -123 +132 @@
         QString file;
         QProcessPrivate *process;
+#if !defined(Q_OS_OS2)
         QSocketNotifier *notifier;
         Q_PIPE pipe[2];
+#else
+        HPIPE pipe;
+        HFILE file;
+#endif
 
         unsigned type : 2;
@@ -168 +182 @@
     QRingBuffer writeBuffer;
 
+#if !defined(Q_OS_OS2)
     Q_PIPE childStartedPipe[2];
     Q_PIPE deathPipe[2];
@@ -179 +194 @@
     QWindowsPipeWriter *pipeWriter;
     QWinEventNotifier *processFinishedNotifier;
+#else
+    void destroyPipe(Channel &channel);
+#endif
 
     void startProcess();