wxProcess-related code now works

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1643 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/msw/utilsexc.cpp

@@ -68,44 +68,80 @@
 #endif
 #include <stdarg.h>
 
-#define wxEXECUTE_WIN_MESSAGE 10000
+// this message is sent when the process we're waiting for terminates
+#define wxWM_PROC_TERMINATED (WM_USER + 10000)
 
-struct wxExecuteData {
+// structure describing the process we're being waiting for
-  HWND window;
+struct wxExecuteData
-  HINSTANCE process;
+{
+public:
+    ~wxExecuteData()
+    {
+        if ( !::CloseHandle(hProcess) )
+        {
+            wxLogLastError("CloseHandle(hProcess)");
+        }
+    }
+
+    HWND       hWnd;          // window to send wxWM_PROC_TERMINATED to
+    HANDLE     hProcess;      // handle of the process
+    DWORD      dwProcessId;   // pid of the process
     wxProcess *handler;
-  char state;
+    DWORD      dwExitCode;    // the exit code of the process
+    bool       state;         // set to FALSE when the process finishes
 };
 
 
 #ifdef __WIN32__
 static DWORD wxExecuteThread(wxExecuteData *data)
 {
-  WaitForSingleObject(data->process, INFINITE);
+    WaitForSingleObject(data->hProcess, INFINITE);
 
-  // Send an implicit message to the window
+    // get the exit code
-  SendMessage(data->window, wxEXECUTE_WIN_MESSAGE, 0, (LPARAM)data);
+    if ( !GetExitCodeProcess(data->hProcess, &data->dwExitCode) )
+    {
+        wxLogLastError("GetExitCodeProcess");
+    }
+
+    wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
+                  "process should have terminated" );
+
+    // send a message indicating process termination to the window
+    SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
     
     return 0;
 }
 #endif
 
-
+// window procedure of a hidden window which is created just to receive
+// the notification message when a process exits
 LRESULT APIENTRY _EXPORT wxExecuteWindowCbk(HWND hWnd, UINT message,
                                             WPARAM wParam, LPARAM lParam)
 {
-  wxExecuteData *data = (wxExecuteData *)lParam;
+    if ( message == wxWM_PROC_TERMINATED )
+    {
+        DestroyWindow(hWnd);    // we don't need it any more
 
-  if (message == wxEXECUTE_WIN_MESSAGE) {
+        wxExecuteData *data = (wxExecuteData *)lParam;
-    DestroyWindow(hWnd);
         if ( data->handler )
-      data->handler->OnTerminate((int)data->process, -1);
+        {
+            data->handler->OnTerminate((int)data->dwProcessId,
+                                       (int)data->dwExitCode);
+        }
         
         if ( data->state )
+        {
+            // we're executing synchronously, tell the waiting thread
+            // that the process finished
             data->state = 0;
+        }
         else
+        {
+            // asynchronous execution - we should do the clean up
             delete data;
         }
+    }
+
     return 0;
 }
 
@@ -113,87 +149,146 @@ extern char wxPanelClassName[];
 
 long wxExecute(const wxString& command, bool sync, wxProcess *handler)
 {
-  if (command == "")
+    wxCHECK_MSG( !!command, 0, "empty command in wxExecute" );
-    return 0;
 
 #if defined(__WIN32__) && !defined(__TWIN32__)
-  char * cl;
+    // the old code is disabled because we really need a process handle
-  char * argp;
+    // if we want to execute it asynchronously or even just get its
-  int clen;
+    // return code and for this we must use CreateProcess() and not
-  HINSTANCE result;
+    // ShellExecute()
-  DWORD dresult;
+#if 0
-  HWND window;
-  wxExecuteData *data;
-  DWORD tid;
-
-  // copy the command line
-  clen = command.Length();
-  if (!clen) return -1;
-  cl = (char *) calloc( 1, 256);
-  if (!cl) return -1;
-  strcpy( cl, WXSTRINGCAST command);
-
     // isolate command and arguments
-  argp = strchr( cl, ' ');
+    wxString commandName;
-  if (argp)
+    bool insideQuotes = FALSE;
-    *argp++ = '\0';
+    const char *pc;
+    for ( pc = command.c_str(); *pc != '\0'; pc++ )
+    {
+        switch ( *pc )
+        {
+            case ' ':
+            case '\t':
+                if ( !insideQuotes )
+                    break;
+                // fall through
 
+            case '"':
+                insideQuotes = !insideQuotes;
+                // fall through
+
+            default:
+                commandName += *pc;
+                continue;   // skip the next break
+        }
+
+        // only reached for space not inside quotes
+        break;
+    }
+
+    wxString commandArgs = pc;
+
+    wxWindow *winTop = wxTheApp->GetTopWindow();
+    HWND hwndTop = (HWND)(winTop ? winTop->GetHWND() : 0);
+
+    HANDLE result;
 #ifdef __GNUWIN32__
-  result = ShellExecute((HWND) (wxTheApp->GetTopWindow() ? (HWND) wxTheApp->GetTopWindow()->GetHWND() : NULL),
+    result = ShellExecute(hwndTop,
-     (const wchar_t) "open", (const wchar_t) cl, (const wchar_t) argp,
+                          (const wchar_t)"open",
-     (const wchar_t) NULL, SW_SHOWNORMAL);
+                          (const wchar_t)commandName,
-#else
+                          (const wchar_t)commandArgs,
-  result = ShellExecute( (HWND) (wxTheApp->GetTopWindow() ? wxTheApp->GetTopWindow()->GetHWND() : NULL),
+                          (const wchar_t)NULL,
-     "open", cl, argp, NULL, SW_SHOWNORMAL);
+                          SW_SHOWNORMAL);
-#endif
+#else // !GNUWIN32
-
+    result = ShellExecute(hwndTop, "open", commandName,
-  if (((long)result) <= 32) {
+                          commandArgs, NULL, SW_SHOWNORMAL);
-   free(cl);
+#endif // GNUWIN32
     
+    if ( ((long)result) <= 32 )
         wxLogSysError(_("Can't execute command '%s'"), command.c_str());
+
+    return result;
+#else // 1
+    // create the process
+    STARTUPINFO si;
+    ::ZeroMemory(&si, sizeof(si));
+    si.cb = sizeof(si);
+
+    PROCESS_INFORMATION pi;
+
+    if ( ::CreateProcess(
+                         NULL,       // application name (use only cmd line)
+                         (char *)command.c_str(),    // full command line
+                         NULL,       // security attributes: defaults for both
+                         NULL,       //   the process and its main thread
+                         FALSE,      // don't inherit handles
+                         CREATE_DEFAULT_ERROR_MODE,  // flags
+                         NULL,       // environment (use the same)
+                         NULL,       // current directory (use the same)
+                         &si,        // startup info (unused here)
+                         &pi         // process info
+                        ) == 0 )
+    {
+        wxLogSysError(_("Execution of command '%s' failed"), command.c_str());
+
         return 0;
     }
 
-  // Alloc data
+    // close unneeded handle
-  data = new wxExecuteData;
+    if ( !::CloseHandle(pi.hThread) )
+        wxLogLastError("CloseHandle(hThread)");
 
-  // Create window
+    // create a hidden window to receive notification about process
-  window = CreateWindow(wxPanelClassName, NULL, 0, 0, 0, 0, 0, NULL,
+    // termination
+    HWND hwnd = ::CreateWindow(wxPanelClassName, NULL, 0, 0, 0, 0, 0, NULL,
                                (HMENU)NULL, wxGetInstance(), 0);
+    wxASSERT_MSG( hwnd, "can't create a hidden window for wxExecute" );
     
     FARPROC ExecuteWindowInstance = MakeProcInstance((FARPROC)wxExecuteWindowCbk,
                                                      wxGetInstance());
     
-  SetWindowLong(window, GWL_WNDPROC, (LONG) ExecuteWindowInstance);
+    ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) ExecuteWindowInstance);
-  SetWindowLong(window, GWL_USERDATA, (LONG) data);
     
-  data->process = result;
+    // Alloc data
-  data->window  = window;
+    wxExecuteData *data = new wxExecuteData;
+    data->hProcess    = pi.hProcess;
+    data->dwProcessId = pi.dwProcessId;
+    data->hWnd        = hwnd;
     data->state       = sync;
-  data->handler = (sync) ? NULL : handler;
+    data->handler     = handler;
 
-  dresult = (DWORD)CreateThread(NULL, 0,
+    DWORD tid;
+    HANDLE hThread = ::CreateThread(NULL,
+                                    0,
                                     (LPTHREAD_START_ROUTINE)wxExecuteThread,
-                                (void *)data, 0, &tid);
+                                    (void *)data,
-  if (dresult == 0) {
+                                    0,
-    wxDebugMsg("wxExecute PANIC: I can't create the waiting thread !"); 
+                                    &tid);
-    DestroyWindow(window);
+
-    return (long)result;
+    if ( !hThread )
+    {
+        wxLogLastError("CreateThread in wxExecute");
+
+        DestroyWindow(hwnd);
+        delete data;
+
+        // the process still started up successfully...
+        return pi.dwProcessId;
     }
     
     if ( !sync )
     {
-    free(cl);
+        // clean up will be done when the process terminates
-    return (long)result;
+        return pi.dwProcessId;
     }
     
     // waiting until command executed
     while ( data->state )
         wxYield();
     
-  free(cl);
+    delete data;
-  return 0;
+
-#else
+    return pi.dwProcessId;
+#endif // 0/1
+#else // Win16
     long instanceID = WinExec((LPCSTR) WXSTRINGCAST command, SW_SHOW);
     if (instanceID < 32) return(0);
     
@@ -204,19 +299,21 @@ long wxExecute(const wxString& command, bool sync, wxProcess *handler)
             running = GetModuleUsage((HANDLE)instanceID);
         } while (running);
     }
+
     return(instanceID);
-#endif
+#endif // Win16/32
 }
 
 long wxExecute(char **argv, bool sync, wxProcess *handler)
 {
-  wxString command = "";
+    wxString command;
     
-  while (*argv != NULL) {
+    while ( *argv != NULL )
-    command += *argv;
+    {
-    command += ' ';
+        command << *argv++ << ' ';
-    argv++;
     }
+
     command.RemoveLast();
+
     return wxExecute(command, sync, handler);
 }