src/msw/utilsexc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/utilsexec.cpp
   3 // Purpose:     Various utilities
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/utils.h"
  33     #include "wx/app.h"
  34     #include "wx/intl.h"
  35 #endif
  36
  37 #include "wx/log.h"
  38
  39 #ifdef __WIN32__
  40     #include "wx/stream.h"
  41     #include "wx/process.h"
  42 #endif
  43
  44 #include "wx/msw/private.h"
  45
  46 #include <ctype.h>
  47
  48 #if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
  49     #include <direct.h>
  50 #ifndef __MWERKS__
  51     #include <dos.h>
  52 #endif
  53 #endif
  54
  55 #if defined(__GNUWIN32__) && !defined(__TWIN32__)
  56     #include <sys/unistd.h>
  57     #include <sys/stat.h>
  58 #endif
  59
  60 #if defined(__WIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)
  61 #include <io.h>
  62
  63 #ifndef __GNUWIN32__
  64 #include <shellapi.h>
  65 #endif
  66 #endif
  67
  68 #include <stdio.h>
  69 #include <stdlib.h>
  70 #include <string.h>
  71 #ifndef __WATCOMC__
  72     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  73         #include <errno.h>
  74     #endif
  75 #endif
  76 #include <stdarg.h>
  77
  78 #if wxUSE_IPC
  79     #include "wx/dde.h"         // for WX_DDE hack in wxExecute
  80 #endif // wxUSE_IPC
  81
  82 // ----------------------------------------------------------------------------
  83 // constants
  84 // ----------------------------------------------------------------------------
  85
  86 // this message is sent when the process we're waiting for terminates
  87 #define wxWM_PROC_TERMINATED (WM_USER + 10000)
  88
  89 // ----------------------------------------------------------------------------
  90 // this module globals
  91 // ----------------------------------------------------------------------------
  92
  93 // we need to create a hidden window to receive the process termination
  94 // notifications and for this we need a (Win) class name for it which we will
  95 // register the first time it's needed
  96 static const wxChar *gs_classForHiddenWindow = NULL;
  97
  98 // ----------------------------------------------------------------------------
  99 // private types
 100 // ----------------------------------------------------------------------------
 101
 102 // structure describing the process we're being waiting for
 103 struct wxExecuteData
 104 {
 105 public:
 106     ~wxExecuteData()
 107     {
 108 #ifndef __WIN16__
 109         if ( !::CloseHandle(hProcess) )
 110         {
 111             wxLogLastError(wxT("CloseHandle(hProcess)"));
 112         }
 113 #endif
 114     }
 115
 116     HWND       hWnd;          // window to send wxWM_PROC_TERMINATED to
 117     HANDLE     hProcess;      // handle of the process
 118     DWORD      dwProcessId;   // pid of the process
 119     wxProcess *handler;
 120     DWORD      dwExitCode;    // the exit code of the process
 121     bool       state;         // set to FALSE when the process finishes
 122 };
 123
 124 #if defined(__WIN32__) && wxUSE_STREAMS
 125
 126 // ----------------------------------------------------------------------------
 127 // wxPipeStreams
 128 // ----------------------------------------------------------------------------
 129
 130 class wxPipeInputStream: public wxInputStream
 131 {
 132 public:
 133     wxPipeInputStream(HANDLE hInput);
 134     ~wxPipeInputStream();
 135
 136     virtual bool Eof() const;
 137
 138 protected:
 139     size_t OnSysRead(void *buffer, size_t len);
 140
 141 protected:
 142     HANDLE m_hInput;
 143 };
 144
 145 class wxPipeOutputStream: public wxOutputStream
 146 {
 147 public:
 148     wxPipeOutputStream(HANDLE hOutput);
 149     ~wxPipeOutputStream();
 150
 151 protected:
 152     size_t OnSysWrite(const void *buffer, size_t len);
 153
 154 protected:
 155     HANDLE m_hOutput;
 156 };
 157
 158 // ==================
 159 // wxPipeInputStream
 160 // ==================
 161
 162 wxPipeInputStream::wxPipeInputStream(HANDLE hInput)
 163 {
 164     m_hInput = hInput;
 165 }
 166
 167 wxPipeInputStream::~wxPipeInputStream()
 168 {
 169     ::CloseHandle(m_hInput);
 170 }
 171
 172 bool wxPipeInputStream::Eof() const
 173 {
 174     DWORD nAvailable;
 175
 176     // function name is misleading, it works with anon pipes as well
 177     DWORD rc = ::PeekNamedPipe
 178                     (
 179                       m_hInput,     // handle
 180                       NULL, 0,      // ptr to buffer and its size
 181                       NULL,         // [out] bytes read
 182                       &nAvailable,  // [out] bytes available
 183                       NULL          // [out] bytes left
 184                     );
 185
 186     if ( !rc )
 187     {
 188         if ( ::GetLastError() != ERROR_BROKEN_PIPE )
 189         {
 190             // unexpected error
 191             wxLogLastError(_T("PeekNamedPipe"));
 192         }
 193
 194         // don't try to continue reading from a pipe if an error occured or if
 195         // it had been closed
 196         return TRUE;
 197     }
 198     else
 199     {
 200         return nAvailable == 0;
 201     }
 202 }
 203
 204 size_t wxPipeInputStream::OnSysRead(void *buffer, size_t len)
 205 {
 206     // reading from a pipe may block if there is no more data, always check for
 207     // EOF first
 208     m_lasterror = wxSTREAM_NOERROR;
 209     if ( Eof() )
 210         return 0;
 211
 212     DWORD bytesRead;
 213     if ( !::ReadFile(m_hInput, buffer, len, &bytesRead, NULL) )
 214     {
 215         if ( ::GetLastError() == ERROR_BROKEN_PIPE )
 216             m_lasterror = wxSTREAM_EOF;
 217         else
 218             m_lasterror = wxSTREAM_READ_ERROR;
 219     }
 220
 221     return bytesRead;
 222 }
 223
 224 // ==================
 225 // wxPipeOutputStream
 226 // ==================
 227
 228 wxPipeOutputStream::wxPipeOutputStream(HANDLE hOutput)
 229 {
 230     m_hOutput = hOutput;
 231 }
 232
 233 wxPipeOutputStream::~wxPipeOutputStream()
 234 {
 235     ::CloseHandle(m_hOutput);
 236 }
 237
 238 size_t wxPipeOutputStream::OnSysWrite(const void *buffer, size_t len)
 239 {
 240     DWORD bytesRead;
 241
 242     m_lasterror = wxSTREAM_NOERROR;
 243     if ( !::WriteFile(m_hOutput, buffer, len, &bytesRead, NULL) )
 244     {
 245         if ( ::GetLastError() == ERROR_BROKEN_PIPE )
 246             m_lasterror = wxSTREAM_EOF;
 247         else
 248             m_lasterror = wxSTREAM_READ_ERROR;
 249     }
 250
 251     return bytesRead;
 252 }
 253
 254 #endif // __WIN32__
 255
 256 // ============================================================================
 257 // implementation
 258 // ============================================================================
 259
 260 #ifdef __WIN32__
 261
 262 static DWORD __stdcall wxExecuteThread(void *arg)
 263 {
 264     wxExecuteData *data = (wxExecuteData*)arg;
 265
 266     WaitForSingleObject(data->hProcess, INFINITE);
 267
 268     // get the exit code
 269     if ( !GetExitCodeProcess(data->hProcess, &data->dwExitCode) )
 270     {
 271         wxLogLastError(wxT("GetExitCodeProcess"));
 272     }
 273
 274     wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
 275                   wxT("process should have terminated") );
 276
 277     // send a message indicating process termination to the window
 278     SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
 279
 280     return 0;
 281 }
 282
 283 // window procedure of a hidden window which is created just to receive
 284 // the notification message when a process exits
 285 LRESULT APIENTRY _EXPORT wxExecuteWindowCbk(HWND hWnd, UINT message,
 286                                             WPARAM wParam, LPARAM lParam)
 287 {
 288     if ( message == wxWM_PROC_TERMINATED )
 289     {
 290         DestroyWindow(hWnd);    // we don't need it any more
 291
 292         wxExecuteData *data = (wxExecuteData *)lParam;
 293         if ( data->handler )
 294         {
 295             data->handler->OnTerminate((int)data->dwProcessId,
 296                                        (int)data->dwExitCode);
 297         }
 298
 299         if ( data->state )
 300         {
 301             // we're executing synchronously, tell the waiting thread
 302             // that the process finished
 303             data->state = 0;
 304         }
 305         else
 306         {
 307             // asynchronous execution - we should do the clean up
 308             delete data;
 309         }
 310
 311         return 0;
 312     }
 313     else
 314     {
 315         return DefWindowProc(hWnd, message, wParam, lParam);
 316     }
 317 }
 318 #endif // Win32
 319
 320 #if wxUSE_IPC
 321
 322 // connect to the given server via DDE and ask it to execute the command
 323 static bool wxExecuteDDE(const wxString& ddeServer,
 324                          const wxString& ddeTopic,
 325                          const wxString& ddeCommand)
 326 {
 327     bool ok;
 328
 329     wxDDEClient client;
 330     wxConnectionBase *conn = client.MakeConnection(_T(""),
 331                                                    ddeServer,
 332                                                    ddeTopic);
 333     if ( !conn )
 334     {
 335         ok = FALSE;
 336     }
 337     else // connected to DDE server
 338     {
 339         // the added complication here is that although most
 340         // programs use XTYP_EXECUTE for their DDE API, some
 341         // important ones - like IE and other MS stuff - use
 342         // XTYP_REQUEST!
 343         //
 344         // so we try it first and then the other one if it
 345         // failed
 346         {
 347             wxLogNull noErrors;
 348             ok = conn->Request(ddeCommand) != NULL;
 349         }
 350
 351         if ( !ok )
 352         {
 353             // now try execute - but show the errors
 354             ok = conn->Execute(ddeCommand);
 355         }
 356     }
 357
 358     return ok;
 359 }
 360
 361 #endif // wxUSE_IPC
 362
 363 long wxExecute(const wxString& cmd, int flags, wxProcess *handler)
 364 {
 365     wxCHECK_MSG( !!cmd, 0, wxT("empty command in wxExecute") );
 366
 367     wxString command;
 368
 369 #if wxUSE_IPC
 370     // DDE hack: this is really not pretty, but we need to allow this for
 371     // transparent handling of DDE servers in wxMimeTypesManager. Usually it
 372     // returns the command which should be run to view/open/... a file of the
 373     // given type. Sometimes, however, this command just launches the server
 374     // and an additional DDE request must be made to really open the file. To
 375     // keep all this well hidden from the application, we allow a special form
 376     // of command: WX_DDE#<command>#DDE_SERVER#DDE_TOPIC#DDE_COMMAND in which
 377     // case we execute just <command> and process the rest below
 378     wxString ddeServer, ddeTopic, ddeCommand;
 379     static const size_t lenDdePrefix = 7;   // strlen("WX_DDE:")
 380     if ( cmd.Left(lenDdePrefix) == _T("WX_DDE#") )
 381     {
 382         // speed up the concatenations below
 383         ddeServer.reserve(256);
 384         ddeTopic.reserve(256);
 385         ddeCommand.reserve(256);
 386
 387         const wxChar *p = cmd.c_str() + 7;
 388         while ( *p && *p != _T('#') )
 389         {
 390             command += *p++;
 391         }
 392
 393         if ( *p )
 394         {
 395             // skip '#'
 396             p++;
 397         }
 398         else
 399         {
 400             wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
 401         }
 402
 403         while ( *p && *p != _T('#') )
 404         {
 405             ddeServer += *p++;
 406         }
 407
 408         if ( *p )
 409         {
 410             // skip '#'
 411             p++;
 412         }
 413         else
 414         {
 415             wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
 416         }
 417
 418         while ( *p && *p != _T('#') )
 419         {
 420             ddeTopic += *p++;
 421         }
 422
 423         if ( *p )
 424         {
 425             // skip '#'
 426             p++;
 427         }
 428         else
 429         {
 430             wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
 431         }
 432
 433         while ( *p )
 434         {
 435             ddeCommand += *p++;
 436         }
 437
 438         // if we want to just launch the program and not wait for its
 439         // termination, try to execute DDE command right now, it can succeed if
 440         // the process is already running - but as it fails if it's not
 441         // running, suppress any errors it might generate
 442         if ( !(flags & wxEXEC_SYNC) )
 443         {
 444             wxLogNull noErrors;
 445             if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCommand) )
 446             {
 447                 // a dummy PID - this is a hack, of course, but it's well worth
 448                 // it as we don't open a new server each time we're called
 449                 // which would be quite bad
 450                 return -1;
 451             }
 452         }
 453     }
 454     else
 455 #endif // wxUSE_IPC
 456     {
 457         // no DDE
 458         command = cmd;
 459     }
 460
 461 #if defined(__WIN32__) && !defined(__TWIN32__)
 462
 463     // the IO redirection is only supported with wxUSE_STREAMS
 464     BOOL redirect = FALSE;
 465 #if wxUSE_STREAMS
 466     // the first elements are reading ends, the second are the writing ones
 467     HANDLE hpipeStdin[2],
 468            hpipeStdout[2],
 469            hpipeStderr[2];
 470     HANDLE hpipeStdinWrite = INVALID_HANDLE_VALUE;
 471
 472     // open the pipes to which child process IO will be redirected if needed
 473     if ( handler && handler->IsRedirected() )
 474     {
 475         // default secutiry attributes
 476         SECURITY_ATTRIBUTES security;
 477
 478         security.nLength              = sizeof(security);
 479         security.lpSecurityDescriptor = NULL;
 480         security.bInheritHandle       = TRUE;
 481
 482         // create stdin pipe
 483         if ( !::CreatePipe(&hpipeStdin[0], &hpipeStdin[1], &security, 0) )
 484         {
 485             wxLogSysError(_("Can't create the inter-process read pipe"));
 486
 487             // indicate failure: we need to return different error code
 488             // depending on the sync flag
 489             return flags & wxEXEC_SYNC ? -1 : 0;
 490         }
 491
 492         // and a stdout one
 493         if ( !::CreatePipe(&hpipeStdout[0], &hpipeStdout[1], &security, 0) )
 494         {
 495             ::CloseHandle(hpipeStdin[0]);
 496             ::CloseHandle(hpipeStdin[1]);
 497
 498             wxLogSysError(_("Can't create the inter-process write pipe"));
 499
 500             return flags & wxEXEC_SYNC ? -1 : 0;
 501         }
 502
 503         (void)::CreatePipe(&hpipeStderr[0], &hpipeStderr[1], &security, 0);
 504
 505         redirect = TRUE;
 506     }
 507 #endif // wxUSE_STREAMS
 508
 509     // create the process
 510     STARTUPINFO si;
 511     wxZeroMemory(si);
 512     si.cb = sizeof(si);
 513
 514 #if wxUSE_STREAMS
 515     if ( redirect )
 516     {
 517         si.dwFlags = STARTF_USESTDHANDLES;
 518
 519         si.hStdInput = hpipeStdin[0];
 520         si.hStdOutput = hpipeStdout[1];
 521         si.hStdError = hpipeStderr[1];
 522
 523         // when the std IO is redirected, we don't show the (console) process
 524         // window by default, but this can be overridden by the caller by
 525         // specifying wxEXEC_NOHIDE flag
 526         if ( !(flags & wxEXEC_NOHIDE) )
 527         {
 528             si.dwFlags |= STARTF_USESHOWWINDOW;
 529             si.wShowWindow = SW_HIDE;
 530         }
 531
 532         // we must duplicate the handle to the write side of stdin pipe to make
 533         // it non inheritable: indeed, we must close hpipeStdin[1] before
 534         // launching the child process as otherwise this handle will be
 535         // inherited by the child which will never close it and so the pipe
 536         // will never be closed and the child will be left stuck in ReadFile()
 537         if ( !::DuplicateHandle
 538                 (
 539                     GetCurrentProcess(),
 540                     hpipeStdin[1],
 541                     GetCurrentProcess(),
 542                     &hpipeStdinWrite,
 543                     0,                      // desired access: unused here
 544                     FALSE,                  // not inherited
 545                     DUPLICATE_SAME_ACCESS   // same access as for src handle
 546                 ) )
 547         {
 548             wxLogLastError(_T("DuplicateHandle"));
 549         }
 550
 551         ::CloseHandle(hpipeStdin[1]);
 552     }
 553 #endif // wxUSE_STREAMS
 554
 555     PROCESS_INFORMATION pi;
 556     DWORD dwFlags = CREATE_DEFAULT_ERROR_MODE | CREATE_SUSPENDED;
 557
 558     bool ok = ::CreateProcess
 559                 (
 560                  NULL,              // application name (use only cmd line)
 561                  (wxChar *)
 562                  command.c_str(),   // full command line
 563                  NULL,              // security attributes: defaults for both
 564                  NULL,              //   the process and its main thread
 565                  redirect,          // inherit handles if we use pipes
 566                  dwFlags,           // process creation flags
 567                  NULL,              // environment (use the same)
 568                  NULL,              // current directory (use the same)
 569                  &si,               // startup info (unused here)
 570                  &pi                // process info
 571                 ) != 0;
 572
 573 #if wxUSE_STREAMS
 574     // we can close the pipe ends used by child anyhow
 575     if ( redirect )
 576     {
 577         ::CloseHandle(hpipeStdin[0]);
 578         ::CloseHandle(hpipeStdout[1]);
 579         ::CloseHandle(hpipeStderr[1]);
 580     }
 581 #endif // wxUSE_STREAMS
 582
 583     if ( !ok )
 584     {
 585 #if wxUSE_STREAMS
 586         // close the other handles too
 587         if ( redirect )
 588         {
 589             ::CloseHandle(hpipeStdout[0]);
 590             ::CloseHandle(hpipeStderr[0]);
 591         }
 592 #endif // wxUSE_STREAMS
 593
 594         wxLogSysError(_("Execution of command '%s' failed"), command.c_str());
 595
 596         return flags & wxEXEC_SYNC ? -1 : 0;
 597     }
 598
 599 #if wxUSE_STREAMS
 600     if ( redirect )
 601     {
 602         // We can now initialize the wxStreams
 603         wxInputStream *inStream = new wxPipeInputStream(hpipeStdout[0]),
 604                       *errStream = new wxPipeInputStream(hpipeStderr[0]);
 605         wxOutputStream *outStream = new wxPipeOutputStream(hpipeStdinWrite);
 606
 607         handler->SetPipeStreams(inStream, outStream, errStream);
 608     }
 609 #endif // wxUSE_STREAMS
 610
 611     // register the class for the hidden window used for the notifications
 612     if ( !gs_classForHiddenWindow )
 613     {
 614         gs_classForHiddenWindow = _T("wxHiddenWindow");
 615
 616         WNDCLASS wndclass;
 617         wxZeroMemory(wndclass);
 618         wndclass.lpfnWndProc   = (WNDPROC)wxExecuteWindowCbk;
 619         wndclass.hInstance     = wxGetInstance();
 620         wndclass.lpszClassName = gs_classForHiddenWindow;
 621
 622         if ( !::RegisterClass(&wndclass) )
 623         {
 624             wxLogLastError(wxT("RegisterClass(hidden window)"));
 625         }
 626     }
 627
 628     // create a hidden window to receive notification about process
 629     // termination
 630     HWND hwnd = ::CreateWindow(gs_classForHiddenWindow, NULL,
 631                                WS_OVERLAPPEDWINDOW,
 632                                0, 0, 0, 0, NULL,
 633                                (HMENU)NULL, wxGetInstance(), 0);
 634     wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
 635
 636     // Alloc data
 637     wxExecuteData *data = new wxExecuteData;
 638     data->hProcess    = pi.hProcess;
 639     data->dwProcessId = pi.dwProcessId;
 640     data->hWnd        = hwnd;
 641     data->state       = (flags & wxEXEC_SYNC) != 0;
 642     if ( flags & wxEXEC_SYNC )
 643     {
 644         // handler may be !NULL for capturing program output, but we don't use
 645         // it wxExecuteData struct in this case
 646         data->handler = NULL;
 647     }
 648     else
 649     {
 650         // may be NULL or not
 651         data->handler = handler;
 652     }
 653
 654     DWORD tid;
 655     HANDLE hThread = ::CreateThread(NULL,
 656                                     0,
 657                                     wxExecuteThread,
 658                                     (void *)data,
 659                                     0,
 660                                     &tid);
 661
 662     // resume process we created now - whether the thread creation succeeded or
 663     // not
 664     if ( ::ResumeThread(pi.hThread) == (DWORD)-1 )
 665     {
 666         // ignore it - what can we do?
 667         wxLogLastError(wxT("ResumeThread in wxExecute"));
 668     }
 669
 670     // close unneeded handle
 671     if ( !::CloseHandle(pi.hThread) )
 672         wxLogLastError(wxT("CloseHandle(hThread)"));
 673
 674     if ( !hThread )
 675     {
 676         wxLogLastError(wxT("CreateThread in wxExecute"));
 677
 678         DestroyWindow(hwnd);
 679         delete data;
 680
 681         // the process still started up successfully...
 682         return pi.dwProcessId;
 683     }
 684
 685     ::CloseHandle(hThread);
 686
 687 #if wxUSE_IPC
 688     // second part of DDE hack: now establish the DDE conversation with the
 689     // just launched process
 690     if ( !ddeServer.empty() )
 691     {
 692         bool ok;
 693
 694         // give the process the time to init itself
 695         //
 696         // we use a very big timeout hoping that WaitForInputIdle() will return
 697         // much sooner, but not INFINITE just in case the process hangs
 698         // completely - like this we will regain control sooner or later
 699         switch ( ::WaitForInputIdle(pi.hProcess, 10000 /* 10 seconds */) )
 700         {
 701             default:
 702                 wxFAIL_MSG( _T("unexpected WaitForInputIdle() return code") );
 703                 // fall through
 704
 705             case -1:
 706                 wxLogLastError(_T("WaitForInputIdle() in wxExecute"));
 707
 708             case WAIT_TIMEOUT:
 709                 wxLogDebug(_T("Timeout too small in WaitForInputIdle"));
 710
 711                 ok = FALSE;
 712                 break;
 713
 714             case 0:
 715                 // ok, process ready to accept DDE requests
 716                 ok = wxExecuteDDE(ddeServer, ddeTopic, ddeCommand);
 717         }
 718     }
 719 #endif // wxUSE_IPC
 720
 721     if ( !(flags & wxEXEC_SYNC) )
 722     {
 723         // clean up will be done when the process terminates
 724
 725         // return the pid
 726         return pi.dwProcessId;
 727     }
 728
 729     // waiting until command executed (disable everything while doing it)
 730 #if wxUSE_GUI
 731     {
 732         wxBusyCursor bc;
 733
 734         wxWindowDisabler wd;
 735 #endif // wxUSE_GUI
 736
 737     while ( data->state )
 738     {
 739         // don't take 100% of the CPU
 740         ::Sleep(500);
 741         wxYield();
 742     }
 743
 744 #if wxUSE_GUI
 745     }
 746 #endif // wxUSE_GUI
 747
 748     DWORD dwExitCode = data->dwExitCode;
 749     delete data;
 750
 751     // return the exit code
 752     return dwExitCode;
 753 #else // Win16
 754     long instanceID = WinExec((LPCSTR) WXSTRINGCAST command, SW_SHOW);
 755     if (instanceID < 32)
 756         return flags & wxEXEC_SYNC ? -1 : 0;
 757
 758     if ( flags & wxEXEC_SYNC )
 759     {
 760         int running;
 761         do
 762         {
 763             wxYield();
 764             running = GetModuleUsage((HINSTANCE)instanceID);
 765         } while (running);
 766     }
 767
 768     return instanceID;
 769 #endif // Win16/32
 770 }
 771
 772 long wxExecute(char **argv, int flags, wxProcess *handler)
 773 {
 774     wxString command;
 775
 776     while ( *argv != NULL )
 777     {
 778         command << *argv++ << ' ';
 779     }
 780
 781     command.RemoveLast();
 782
 783     return wxExecute(command, flags, handler);
 784 }
 785