added and documented wxDir::HasFiles/SubDirs(), use the latter in wxDirDialog - it...

[wxWidgets.git] / src / unix / utilsunx.cpp

diff --git a/src/unix/utilsunx.cpp b/src/unix/utilsunx.cpp
index a3f3641c03d1e8fb84e0a666153a2bb9b62c2641..ad8a078fabd6c6d96e2bf1a4e514748e168e4634 100644 (file)
--- a/src/unix/utilsunx.cpp
+++ b/src/unix/utilsunx.cpp
@@ -32,6 +32,12 @@
     #include "wx/unix/execute.h"
 #endif
 
     #include "wx/unix/execute.h"
 #endif
 

+// SGI signal.h defines signal handler arguments differently depending on
+// whether _LANGUAGE_C_PLUS_PLUS is set or not - do set it
+#if defined(__SGI__) && !defined(_LANGUAGE_C_PLUS_PLUS)
+    #define _LANGUAGE_C_PLUS_PLUS 1
+#endif // SGI hack
+

 #include <stdarg.h>
 #include <dirent.h>
 #include <string.h>
 #include <stdarg.h>
 #include <dirent.h>
 #include <string.h>


@@ -129,9 +135,39 @@ void wxUsleep(unsigned long milliseconds)
 // process management
 // ----------------------------------------------------------------------------
 
 // process management
 // ----------------------------------------------------------------------------
 

-int wxKill(long pid, wxSignal sig)
+int wxKill(long pid, wxSignal sig, wxKillError *rc)

 {
 {

-    return kill((pid_t)pid, (int)sig);
+    int err = kill((pid_t)pid, (int)sig);
+    if ( rc )
+    {
+        switch ( err )
+        {
+            case 0:
+                *rc = wxKILL_OK;
+                break;
+
+            case EINVAL:
+                *rc = wxKILL_BAD_SIGNAL;
+                break;
+
+            case EPERM:
+                *rc = wxKILL_ACCESS_DENIED;
+                break;
+
+            case ESRCH:
+                *rc = wxKILL_NO_PROCESS;
+                break;
+
+            default:
+                // this goes against Unix98 docs so log it
+                wxLogDebug(_T("unexpected kill(2) return value %d"), err);
+
+                // something else...
+                *rc = wxKILL_ERROR;
+        }
+    }
+
+    return err;

 }
 
 #define WXEXECUTE_NARGS   127
 }
 
 #define WXEXECUTE_NARGS   127


@@ -297,6 +333,8 @@ void wxHandleProcessTermination(wxEndProcessData *proc_data)
 // wxStream classes to support IO redirection in wxExecute
 // ----------------------------------------------------------------------------
 
 // wxStream classes to support IO redirection in wxExecute
 // ----------------------------------------------------------------------------
 

+#if wxUSE_STREAMS
+

 class wxProcessFileInputStream : public wxInputStream
 {
 public:
 class wxProcessFileInputStream : public wxInputStream
 {
 public:


@@ -393,11 +431,20 @@ size_t wxProcessFileOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
     return ret;
 }
 
     return ret;
 }
 

+#endif // wxUSE_STREAMS
+

 long wxExecute(wxChar **argv,
                bool sync,
                wxProcess *process)
 {
 long wxExecute(wxChar **argv,
                bool sync,
                wxProcess *process)
 {

-    wxCHECK_MSG( *argv, 0, wxT("can't exec empty command") );
+    // for the sync execution, we return -1 to indicate failure, but for async
+    // case we return 0 which is never a valid PID
+    //
+    // we define this as a macro, not a variable, to avoid compiler warnings
+    // about "ERROR_RETURN_CODE value may be clobbered by fork()"
+    #define ERROR_RETURN_CODE ((sync) ? -1 : 0)
+
+    wxCHECK_MSG( *argv, ERROR_RETURN_CODE, wxT("can't exec empty command") );

 
 #if wxUSE_UNICODE
     int mb_argc = 0;
 
 #if wxUSE_UNICODE
     int mb_argc = 0;


@@ -432,18 +479,22 @@ long wxExecute(wxChar **argv,
 
         ARGS_CLEANUP;
 
 
         ARGS_CLEANUP;
 

-        return 0;
+        return ERROR_RETURN_CODE;

     }
 #endif // wxUSE_GUI
 
     }
 #endif // wxUSE_GUI
 

-    int pipeIn[2];
-    int pipeOut[2];
+    // pipes for inter process communication
+    int pipeIn[2],      // stdin
+        pipeOut[2],     // stdout
+        pipeErr[2];     // stderr
+

     pipeIn[0] = pipeIn[1] =
     pipeIn[0] = pipeIn[1] =

-    pipeOut[0] = pipeOut[1] = -1;
+    pipeOut[0] = pipeOut[1] =
+    pipeErr[0] = pipeErr[1] = -1;

 
     if ( process && process->IsRedirected() )
     {
 
     if ( process && process->IsRedirected() )
     {

-        if ( pipe(pipeIn) == -1 || pipe(pipeOut) == -1 )
+        if ( pipe(pipeIn) == -1 || pipe(pipeOut) == -1 || pipe(pipeErr) == -1 )

         {
 #if wxUSE_GUI
             // free previously allocated resources
         {
 #if wxUSE_GUI
             // free previously allocated resources


@@ -456,7 +507,7 @@ long wxExecute(wxChar **argv,
 
             ARGS_CLEANUP;
 
 
             ARGS_CLEANUP;
 

-            return 0;
+            return ERROR_RETURN_CODE;

         }
     }
 
         }
     }
 


@@ -476,13 +527,15 @@ long wxExecute(wxChar **argv,
         close(pipeIn[1]);
         close(pipeOut[0]);
         close(pipeOut[1]);
         close(pipeIn[1]);
         close(pipeOut[0]);
         close(pipeOut[1]);

+        close(pipeErr[0]);
+        close(pipeErr[1]);

 #endif // wxUSE_GUI
 
         wxLogSysError( _("Fork failed") );
 
         ARGS_CLEANUP;
 
 #endif // wxUSE_GUI
 
         wxLogSysError( _("Fork failed") );
 
         ARGS_CLEANUP;
 

-        return 0;
+        return ERROR_RETURN_CODE;

     }
     else if ( pid == 0 )  // we're in child
     {
     }
     else if ( pid == 0 )  // we're in child
     {


@@ -498,7 +551,7 @@ long wxExecute(wxChar **argv,
         {
             for ( int fd = 0; fd < FD_SETSIZE; fd++ )
             {
         {
             for ( int fd = 0; fd < FD_SETSIZE; fd++ )
             {

-                if ( fd == pipeIn[0] || fd == pipeOut[1]
+                if ( fd == pipeIn[0] || fd == pipeOut[1] || fd == pipeErr[1]

 #if wxUSE_GUI
                      || fd == end_proc_detect[1]
 #endif // wxUSE_GUI
 #if wxUSE_GUI
                      || fd == end_proc_detect[1]
 #endif // wxUSE_GUI


@@ -514,19 +567,19 @@ long wxExecute(wxChar **argv,
             }
         }
 
             }
         }
 

-        // redirect stdio and stdout
-        // (TODO: what about stderr?)
+        // redirect stdio, stdout and stderr

         if ( pipeIn[0] != -1 )
         {
             if ( dup2(pipeIn[0], STDIN_FILENO) == -1 ||
         if ( pipeIn[0] != -1 )
         {
             if ( dup2(pipeIn[0], STDIN_FILENO) == -1 ||

-                 dup2(pipeOut[1], STDOUT_FILENO) == -1 )
+                 dup2(pipeOut[1], STDOUT_FILENO) == -1 ||
+                 dup2(pipeErr[1], STDERR_FILENO) == -1 )

             {
             {

-                wxLogSysError(_("Failed to redirect child process "
-                                "input/output"));
+                wxLogSysError(_("Failed to redirect child process input/output"));

             }
 
             close(pipeIn[0]);
             close(pipeOut[1]);
             }
 
             close(pipeIn[0]);
             close(pipeOut[1]);

+            close(pipeErr[1]);

         }
 
         execvp (*mb_argv, mb_argv);
         }
 
         execvp (*mb_argv, mb_argv);


@@ -541,16 +594,21 @@ long wxExecute(wxChar **argv,
         // pipe initialization: construction of the wxStreams
         if ( process && process->IsRedirected() )
         {
         // pipe initialization: construction of the wxStreams
         if ( process && process->IsRedirected() )
         {

+#if wxUSE_STREAMS

             // These two streams are relative to this process.
             wxOutputStream *outStream = new wxProcessFileOutputStream(pipeIn[1]);
             wxInputStream *inStream = new wxProcessFileInputStream(pipeOut[0]);
             // These two streams are relative to this process.
             wxOutputStream *outStream = new wxProcessFileOutputStream(pipeIn[1]);
             wxInputStream *inStream = new wxProcessFileInputStream(pipeOut[0]);

+            wxInputStream *errStream = new wxProcessFileInputStream(pipeErr[0]);
+
+            process->SetPipeStreams(inStream, outStream, errStream);
+#endif // wxUSE_STREAMS
+

             close(pipeIn[0]); // close reading side
             close(pipeOut[1]); // close writing side
             close(pipeIn[0]); // close reading side
             close(pipeOut[1]); // close writing side

-
-            process->SetPipeStreams(inStream, outStream);
+            close(pipeErr[1]); // close writing side

         }
 
         }
 

-#if wxUSE_GUI
+#if wxUSE_GUI && !defined(__WXMICROWIN__)

         wxEndProcessData *data = new wxEndProcessData;
 
         if ( sync )
         wxEndProcessData *data = new wxEndProcessData;
 
         if ( sync )


@@ -603,12 +661,18 @@ long wxExecute(wxChar **argv,
         return exitcode;
 #endif // wxUSE_GUI
     }
         return exitcode;
 #endif // wxUSE_GUI
     }

-
-    return 0;
-
-    #undef ARGS_CLEANUP
+#ifdef __VMS
+   // VMS does not recognise exit as a return and complains about
+   // a missing return
+   // I think VMS is wrong in this
+   //     JJ
+   return 0;
+#endif

 }
 
 }
 

+#undef ERROR_RETURN_CODE
+#undef ARGS_CLEANUP
+

 // ----------------------------------------------------------------------------
 // file and directory functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // file and directory functions
 // ----------------------------------------------------------------------------


@@ -616,9 +680,14 @@ long wxExecute(wxChar **argv,
 const wxChar* wxGetHomeDir( wxString *home  )
 {
     *home = wxGetUserHome( wxString() );
 const wxChar* wxGetHomeDir( wxString *home  )
 {
     *home = wxGetUserHome( wxString() );

+   wxString tmp;

     if ( home->IsEmpty() )
         *home = wxT("/");
     if ( home->IsEmpty() )
         *home = wxT("/");

-
+#ifdef __VMS
+   tmp = *home;
+   if ( tmp.Last() != wxT(']'))
+     if ( tmp.Last() != wxT('/')) *home << wxT('/');
+#endif

     return home->c_str();
 }
 
     return home->c_str();
 }
 


@@ -763,7 +832,7 @@ bool wxGetUserName(wxChar *buf, int sz)
     if ((who = getpwuid (getuid ())) != NULL)
     {
         // pw_gecos field in struct passwd is not standard
     if ((who = getpwuid (getuid ())) != NULL)
     {
         // pw_gecos field in struct passwd is not standard

-#if HAVE_PW_GECOS
+#ifdef HAVE_PW_GECOS

        char *comma = strchr(who->pw_gecos, ',');
        if (comma)
            *comma = '\0'; // cut off non-name comment fields
        char *comma = strchr(who->pw_gecos, ',');
        if (comma)
            *comma = '\0'; // cut off non-name comment fields


@@ -786,6 +855,102 @@ wxString wxGetOsDescription()
 #endif
 }
 
 #endif
 }
 

+// this function returns the GUI toolkit version in GUI programs, but OS
+// version in non-GUI ones
+#if !wxUSE_GUI
+
+int wxGetOsVersion(int *majorVsn, int *minorVsn)
+{
+    int major, minor;
+    char name[256];
+
+    if ( sscanf(WXWIN_OS_DESCRIPTION, "%s %d.%d", name, &major, &minor) != 3 )
+    {
+        // unreckognized uname string format
+        major = minor = -1;
+    }
+
+    if ( majorVsn )
+        *majorVsn = major;
+    if ( minorVsn )
+        *minorVsn = minor;
+
+    return wxUNIX;
+}
+
+#endif // !wxUSE_GUI
+
+long wxGetFreeMemory()
+{
+#if defined(__LINUX__)
+    // get it from /proc/meminfo
+    FILE *fp = fopen("/proc/meminfo", "r");
+    if ( fp )
+    {
+        long memFree = -1;
+
+        char buf[1024];
+        if ( fgets(buf, WXSIZEOF(buf), fp) && fgets(buf, WXSIZEOF(buf), fp) )
+        {
+            long memTotal, memUsed;
+            sscanf(buf, "Mem: %ld %ld %ld", &memTotal, &memUsed, &memFree);
+        }
+
+        fclose(fp);
+
+        return memFree;
+    }
+#elif defined(__SUN__) && defined(_SC_AVPHYS_PAGES)
+    return sysconf(_SC_AVPHYS_PAGES)*sysconf(_SC_PAGESIZE);
+//#elif defined(__FREEBSD__) -- might use sysctl() to find it out, probably
+#endif
+
+    // can't find it out
+    return -1;
+}
+
+// ----------------------------------------------------------------------------
+// env vars
+// ----------------------------------------------------------------------------
+
+bool wxGetEnv(const wxString& var, wxString *value)
+{
+    // wxGetenv is defined as getenv()
+    wxChar *p = wxGetenv(var);
+    if ( !p )
+        return FALSE;
+
+    if ( value )
+    {
+        *value = p;
+    }
+
+    return TRUE;
+}
+
+bool wxSetEnv(const wxString& variable, const wxChar *value)
+{
+#if defined(HAVE_SETENV)
+    return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
+                                           : NULL, 1 /* overwrite */) == 0;
+#elif defined(HAVE_PUTENV)
+    wxString s = variable;
+    if ( value )
+        s << _T('=') << value;
+
+    // transform to ANSI
+    const char *p = s.mb_str();
+
+    // the string will be free()d by libc
+    char *buf = (char *)malloc(strlen(p) + 1);
+    strcpy(buf, p);
+
+    return putenv(buf) == 0;
+#else // no way to set an env var
+    return FALSE;
+#endif
+}
+

 // ----------------------------------------------------------------------------
 // signal handling
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // signal handling
 // ----------------------------------------------------------------------------


@@ -794,7 +959,7 @@ wxString wxGetOsDescription()
 
 #include <signal.h>
 
 
 #include <signal.h>
 

-static void wxFatalSignalHandler(int signal)
+static void wxFatalSignalHandler(wxTYPE_SA_HANDLER)

 {
     if ( wxTheApp )
     {
 {
     if ( wxTheApp )
     {