removed log record

[wxWidgets.git] / src / os2 / utilsexc.cpp

diff --git a/src/os2/utilsexc.cpp b/src/os2/utilsexc.cpp
index 4c6c00399ea55831871991e54fc1ed06d4c15c60..f9f3885e1673fc3ba8472c4a7a32cbb92ec5bc8c 100644 (file)
--- a/src/os2/utilsexc.cpp
+++ b/src/os2/utilsexc.cpp
@@ -25,11 +25,17 @@
 
 #include "wx/os2/private.h"
 
 
 #include "wx/os2/private.h"
 

-#define INCL_DOS
-#include <os2.h>
+#define PURE_32
+#ifndef __EMX__
+#include <upm.h>
+#include <netcons.h>
+#include <netbios.h>
+#endif

 
 #include <ctype.h>
 
 #include <ctype.h>

-#include <direct.h>
+#ifdef __EMX__
+#include <dirent.h>
+#endif

 
 #include <sys/stat.h>
 #include <io.h>
 
 #include <sys/stat.h>
 #include <io.h>


@@ -40,223 +46,230 @@
 #include <errno.h>
 #include <stdarg.h>
 
 #include <errno.h>
 #include <stdarg.h>
 

+

 // this message is sent when the process we're waiting for terminates
 #define wxWM_PROC_TERMINATED (WM_USER + 10000)
 
 // this message is sent when the process we're waiting for terminates
 #define wxWM_PROC_TERMINATED (WM_USER + 10000)
 

+#ifndef NO_ERROR
+#  define NO_ERROR  0
+#endif
+

 // structure describing the process we're being waiting for
 struct wxExecuteData
 {
 public:
     ~wxExecuteData()
     {
 // structure describing the process we're being waiting for
 struct wxExecuteData
 {
 public:
     ~wxExecuteData()
     {

-// TODO:
-/*
-        if ( !::CloseHandle(hProcess) )
-        {
-            wxLogLastError("CloseHandle(hProcess)");
-        }
-*/
+//         cout << "Closing thread: " << endl;
+        DosExit(EXIT_PROCESS, 0);

     }
 
     }
 

-    HWND       hWnd;          // window to send wxWM_PROC_TERMINATED to
-    HANDLE     hProcess;      // handle of the process
-    DWORD      dwProcessId;   // pid of the process
-    wxProcess *handler;
-    DWORD      dwExitCode;    // the exit code of the process
-    bool       state;         // set to FALSE when the process finishes
+    HWND                            hWnd;          // window to send wxWM_PROC_TERMINATED to [not used]
+    RESULTCODES                     vResultCodes;
+    wxProcess*                      pHandler;
+    ULONG                           ulExitCode;    // the exit code of the process
+    bool                            bState;        // set to FALSE when the process finishes

 };
 
 };
 

-
-static DWORD wxExecuteThread(wxExecuteData *data)
+static ULONG wxExecuteThread(
+  wxExecuteData*                    pData
+)

 {
 {

-// TODO:
-/*
-    WaitForSingleObject(data->hProcess, INFINITE);
-
-    // get the exit code
-    if ( !GetExitCodeProcess(data->hProcess, &data->dwExitCode) )
+    ULONG                           ulRc;
+    PID                             vPidChild;
+
+//     cout << "Executing thread: " << endl;
+
+    ulRc = ::DosWaitChild( DCWA_PROCESSTREE
+                          ,DCWW_NOWAIT
+                          ,&pData->vResultCodes
+                          ,&vPidChild
+                          ,pData->vResultCodes.codeTerminate // process PID to look at
+                         );
+    if (ulRc != NO_ERROR)

     {
     {

-        wxLogLastError("GetExitCodeProcess");
+        wxLogLastError("DosWaitChild");

     }
     }

-
-    wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
-                  wxT("process should have terminated") );
-
-    // send a message indicating process termination to the window
-    SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
-*/
+    delete pData;

     return 0;
 }
 
 // window procedure of a hidden window which is created just to receive
 // the notification message when a process exits
     return 0;
 }
 
 // window procedure of a hidden window which is created just to receive
 // the notification message when a process exits

-MRESULT APIENTRY wxExecuteWindowCbk(HWND hWnd, UINT message,
-                                    MPARAM wParam, MPARAM lParam)
+MRESULT APIENTRY wxExecuteWindowCbk(
+  HWND                              hWnd
+, ULONG                             ulMessage
+, MPARAM                            wParam
+, MPARAM                            lParam
+)

 {
 {

-    if ( message == wxWM_PROC_TERMINATED )
+    if (ulMessage == wxWM_PROC_TERMINATED)

     {
     {

-//        DestroyWindow(hWnd);    // we don't need it any more
+        wxExecuteData*              pData = (wxExecuteData *)lParam;

 
 

-        wxExecuteData *data = (wxExecuteData *)lParam;
-        if ( data->handler )
+        if (pData->pHandler)

         {
         {

-            data->handler->OnTerminate((int)data->dwProcessId,
-                                       (int)data->dwExitCode);
+            pData->pHandler->OnTerminate( (int)pData->vResultCodes.codeTerminate
+                                         ,(int)pData->vResultCodes.codeResult
+                                        );

         }
 
         }
 

-        if ( data->state )
+        if (pData->bState)

         {
             // we're executing synchronously, tell the waiting thread
             // that the process finished
         {
             // we're executing synchronously, tell the waiting thread
             // that the process finished

-            data->state = 0;
+            pData->bState = 0;

         }
         else
         {
             // asynchronous execution - we should do the clean up
         }
         else
         {
             // asynchronous execution - we should do the clean up

-            delete data;
+            delete pData;

         }
         }

+        ::WinDestroyWindow(hWnd);    // we don't need it any more

     }
     }

-

     return 0;
 }
 
 extern wxChar wxPanelClassName[];
 
     return 0;
 }
 
 extern wxChar wxPanelClassName[];
 

-long wxExecute(const wxString& command, bool sync, wxProcess *handler)
+long wxExecute(
+  const wxString&                   rCommand
+, bool                              bSync
+, wxProcess*                        pHandler
+)

 {
 {

-    wxCHECK_MSG( !!command, 0, wxT("empty command in wxExecute") );
-
-    // the old code is disabled because we really need a process handle
-    // if we want to execute it asynchronously or even just get its
-    // return code and for this we must use CreateProcess() and not
-    // ShellExecute()
+    if (rCommand.IsEmpty())
+    {
+//         cout << "empty command in wxExecute." << endl;
+        return 0;
+    }

 
     // create the process
 
     // create the process

-// TODO:
-/*
-    STARTUPINFO si;
-    memset(&si, 0, sizeof(si));
-    si.cb = sizeof(si);
-
-    PROCESS_INFORMATION pi;
-
-    if ( ::CreateProcess(
-                         NULL,       // application name (use only cmd line)
-                         (wxChar *)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 )
+    UCHAR                           vLoadError[CCHMAXPATH] = {0};
+    RESULTCODES                     vResultCodes = {0};
+    ULONG                           ulExecFlag;
+    PSZ                             zArgs = NULL;
+    PSZ                             zEnvs = NULL;
+    ULONG                           ulWindowId;
+    APIRET                          rc;
+    PFNWP                           pOldProc;
+    TID                             vTID;
+
+    if (bSync)
+        ulExecFlag = EXEC_SYNC;
+    else
+        ulExecFlag = EXEC_ASYNCRESULT;
+
+    rc = ::DosExecPgm( (PCHAR)vLoadError
+                      ,sizeof(vLoadError)
+                      ,ulExecFlag
+                      ,zArgs
+                      ,zEnvs
+                      ,&vResultCodes
+                      ,(PSZ)rCommand.c_str()
+                     );
+    if (rc != NO_ERROR)

     {
     {

-        wxLogSysError(_("Execution of command '%s' failed"), command.c_str());
-
+        wxLogSysError(_("Execution of command '%s' failed with error: %ul"), rCommand.c_str(), rc);

         return 0;
     }
         return 0;
     }

-
-    // close unneeded handle
-    if ( !::CloseHandle(pi.hThread) )
-        wxLogLastError("CloseHandle(hThread)");
-
-    // create a hidden window to receive notification about process
-    // termination
-    HWND hwnd = ::CreateWindow(wxPanelClassName, NULL, 0, 0, 0, 0, 0, NULL,
-                               (HMENU)NULL, wxGetInstance(), 0);
-    wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
-
-    FARPROC ExecuteWindowInstance = MakeProcInstance((FARPROC)wxExecuteWindowCbk,
-                                                     wxGetInstance());
-
-    ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) ExecuteWindowInstance);
-
+//     cout << "Executing: " << rCommand.c_str() << endl;

     // Alloc data
     // Alloc data

-    wxExecuteData *data = new wxExecuteData;
-    data->hProcess    = pi.hProcess;
-    data->dwProcessId = pi.dwProcessId;
-    data->hWnd        = hwnd;
-    data->state       = sync;
-    if ( sync )
-    {
-        wxASSERT_MSG( !handler, wxT("wxProcess param ignored for sync execution") );
+    wxExecuteData*                  pData = new wxExecuteData;

 
 

-        data->handler = NULL;
+    pData->vResultCodes = vResultCodes;
+    pData->hWnd         = NULLHANDLE;
+    pData->bState       = bSync;
+    if (bSync)
+    {
+        wxASSERT_MSG(!pHandler, wxT("wxProcess param ignored for sync execution"));
+        pData->pHandler = NULL;

     }
     else
     {
         // may be NULL or not
     }
     else
     {
         // may be NULL or not

-        data->handler = handler;
+        pData->pHandler = pHandler;

     }
 
     }
 

-    DWORD tid;
-    HANDLE hThread = ::CreateThread(NULL,
-                                    0,
-                                    (LPTHREAD_START_ROUTINE)wxExecuteThread,
-                                    (void *)data,
-                                    0,
-                                    &tid);
-
-    if ( !hThread )
+    rc = ::DosCreateThread( &vTID
+                           ,(PFNTHREAD)&wxExecuteThread
+                           ,(ULONG)pData
+                           ,CREATE_READY|STACK_SPARSE
+                           ,8192
+                          );
+    if (rc != NO_ERROR)

     {
         wxLogLastError("CreateThread in wxExecute");
     {
         wxLogLastError("CreateThread in wxExecute");

-
-        DestroyWindow(hwnd);
-        delete data;
+        delete pData;

 
         // the process still started up successfully...
 
         // the process still started up successfully...

-        return pi.dwProcessId;
+        return vResultCodes.codeTerminate;

     }
     }

-
-    if ( !sync )
+    if (!bSync)

     {
     {

-        // clean up will be done when the process terminates
-

         // return the pid
         // return the pid

-        return pi.dwProcessId;
+        // warning: don't exit your app unless you actively
+        // kill and cleanup you child processes
+        // Maybe detach the process here???
+        // If cmd.exe need to pass DETACH to detach the process here
+        return vResultCodes.codeTerminate;

     }
 
     // waiting until command executed
     }
 
     // waiting until command executed

-    while ( data->state )
-        wxYield();
+    ::DosWaitThread(&vTID, DCWW_WAIT);

 
 

-    DWORD dwExitCode = data->dwExitCode;
-    delete data;
+    ULONG ulExitCode = pData->vResultCodes.codeResult;
+    delete pData;

 
     // return the exit code
 
     // return the exit code

-    return dwExitCode;
-*/
-    return 0;
+    return (long)ulExitCode;

 }
 
 }
 

-long wxExecute(char **argv, bool sync, wxProcess *handler)
+long wxExecute(
+  char**                            ppArgv
+, bool                              bSync
+, wxProcess*                        pHandler
+)

 {
 {

-    wxString command;
+    wxString                        sCommand;

 
 

-    while ( *argv != NULL )
+    while (*ppArgv != NULL)

     {
     {

-        command << *argv++ << ' ';
+        sCommand << *ppArgv++ << ' ';

     }
     }

-
-    command.RemoveLast();
-
-    return wxExecute(command, sync, handler);
+    sCommand.RemoveLast();
+    return wxExecute( sCommand
+                     ,bSync
+                     ,pHandler
+                    );

 }
 
 }
 

-bool wxGetFullHostName(wxChar *buf, int maxSize)
+bool wxGetFullHostName(
+  wxChar*                           zBuf
+, int                               nMaxSize
+)

 {
 {

-    DWORD nSize = maxSize ;
-// TODO:
-/*
-    if ( !::GetComputerName(buf, &nSize) )
-    {
-        wxLogLastError("GetComputerName");
-
-        return FALSE;
-    }
-*/
+#if wxUSE_NET_API
+    char                            zServer[256];
+    char                            zComputer[256];
+    unsigned long                   ulLevel = 0;
+    unsigned char*                  zBuffer = NULL;
+    unsigned long                   ulBuffer = 256;
+    unsigned long*                  pulTotalAvail = NULL;
+
+    NetBios32GetInfo( (const unsigned char*)zServer
+                     ,(const unsigned char*)zComputer
+                     ,ulLevel
+                     ,zBuffer
+                     ,ulBuffer
+                     ,pulTotalAvail
+                    );
+    strncpy(zBuf, zComputer, nMaxSize);
+    zBuf[nMaxSize] = _T('\0');
+#else
+    strcpy(zBuf, "noname");
+#endif
+    return *zBuf ? TRUE : FALSE;

     return TRUE;
 }
 
     return TRUE;
 }