X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b2ddee86fe73c5ae8edc59871fea9f40e84cbc2d..ffafd8a55bb0b8fb4236e4522792a6b143813609:/src/unix/utilsunx.cpp?ds=sidebyside diff --git a/src/unix/utilsunx.cpp b/src/unix/utilsunx.cpp index 4cb88a61b9..8709321cf1 100644 --- a/src/unix/utilsunx.cpp +++ b/src/unix/utilsunx.cpp @@ -15,12 +15,16 @@ // headers // ---------------------------------------------------------------------------- +// for compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + #include "wx/defs.h" #include "wx/string.h" #include "wx/intl.h" #include "wx/log.h" #include "wx/app.h" +#include "wx/apptrait.h" #include "wx/utils.h" #include "wx/process.h" @@ -28,29 +32,48 @@ #include "wx/wfstream.h" +#include "wx/unix/execute.h" + +#if wxUSE_STREAMS + +// define this to let wxexec.cpp know that we know what we're doing +#define _WX_USED_BY_WXEXECUTE_ +#include "../common/execcmn.cpp" + +#endif // wxUSE_STREAMS + +#if wxUSE_BASE + +#if defined( __MWERKS__ ) && defined(__MACH__) +#define WXWIN_OS_DESCRIPTION "MacOS X" +#define HAVE_NANOSLEEP +#endif + +// not only the statfs syscall is called differently depending on platform, but +// one of its incarnations, statvfs(), takes different arguments under +// different platforms and even different versions of the same system (Solaris +// 7 and 8): if you want to test for this, don't forget that the problems only +// appear if the large files support is enabled #ifdef HAVE_STATFS -# ifdef __BSD__ -# include -# include -# else -# include -# endif + #ifdef __BSD__ + #include + #include + #else // !__BSD__ + #include + #endif // __BSD__/!__BSD__ + + #define wxStatfs statfs #endif // HAVE_STATFS -// not only the statfs syscall is called differently depending on platform, but -// we also can't use "struct statvfs" under Solaris because it breaks down if -// HAVE_LARGEFILE_SUPPORT == 1 and we must use statvfs_t instead #ifdef HAVE_STATVFS #include - #define statfs statvfs - #define wxStatFs statvfs_t -#elif HAVE_STATFS - #define wxStatFs struct statfs -#endif // HAVE_STAT[V]FS + #define wxStatfs statvfs +#endif // HAVE_STATVFS -#if wxUSE_GUI - #include "wx/unix/execute.h" +#if defined(HAVE_STATFS) || defined(HAVE_STATVFS) + // WX_STATFS_T is detected by configure + #define wxStatfs_t WX_STATFS_T #endif // SGI signal.h defines signal handler arguments differently depending on @@ -64,8 +87,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -197,6 +220,16 @@ long wxExecute( const wxString& command, int flags, wxProcess *process ) { wxCHECK_MSG( !command.IsEmpty(), 0, wxT("can't exec empty command") ); +#if wxUSE_THREADS + // fork() doesn't mix well with POSIX threads: on many systems the program + // deadlocks or crashes for some reason. Probably our code is buggy and + // doesn't do something which must be done to allow this to work, but I + // don't know what yet, so for now just warn the user (this is the least we + // can do) about it + wxASSERT_MSG( wxThread::IsMain(), + _T("wxExecute() can be called only from the main thread") ); +#endif // wxUSE_THREADS + int argc = 0; wxChar *argv[WXEXECUTE_NARGS]; wxString argument; @@ -253,11 +286,7 @@ long wxExecute( const wxString& command, int flags, wxProcess *process ) argv[argc] = NULL; // do execute the command -#if wxUSE_UNICODE - long lRc = -1; -#else long lRc = wxExecute(argv, flags, process); -#endif // clean up argc = 0; @@ -323,53 +352,13 @@ bool wxShutdown(wxShutdownFlags wFlags) } -#if wxUSE_GUI - -void wxHandleProcessTermination(wxEndProcessData *proc_data) -{ - // notify user about termination if required - if ( proc_data->process ) - { - proc_data->process->OnTerminate(proc_data->pid, proc_data->exitcode); - } - - // clean up - if ( proc_data->pid > 0 ) - { - delete proc_data; - } - else - { - // let wxExecute() know that the process has terminated - proc_data->pid = 0; - } -} - -#endif // wxUSE_GUI - // ---------------------------------------------------------------------------- // wxStream classes to support IO redirection in wxExecute // ---------------------------------------------------------------------------- #if wxUSE_STREAMS -// ---------------------------------------------------------------------------- -// wxPipeInputStream: stream for reading from a pipe -// ---------------------------------------------------------------------------- - -class wxPipeInputStream : public wxFileInputStream -{ -public: - wxPipeInputStream(int fd) : wxFileInputStream(fd) { } - - // return TRUE if the pipe is still opened - bool IsOpened() const { return !Eof(); } - - // return TRUE if we have anything to read, don't block - bool IsAvailable() const; -}; - -bool wxPipeInputStream::IsAvailable() const +bool wxPipeInputStream::CanRead() const { if ( m_lasterror == wxSTREAM_EOF ) return FALSE; @@ -405,89 +394,8 @@ bool wxPipeInputStream::IsAvailable() const } } -// define this to let wxexec.cpp know that we know what we're doing -#define _WX_USED_BY_WXEXECUTE_ -#include "../common/execcmn.cpp" - #endif // wxUSE_STREAMS -// ---------------------------------------------------------------------------- -// wxPipe: this encapsulates pipe() system call -// ---------------------------------------------------------------------------- - -class wxPipe -{ -public: - // the symbolic names for the pipe ends - enum Direction - { - Read, - Write - }; - - enum - { - INVALID_FD = -1 - }; - - // default ctor doesn't do anything - wxPipe() { m_fds[Read] = m_fds[Write] = INVALID_FD; } - - // create the pipe, return TRUE if ok, FALSE on error - bool Create() - { - if ( pipe(m_fds) == -1 ) - { - wxLogSysError(_("Pipe creation failed")); - - return FALSE; - } - - return TRUE; - } - - // return TRUE if we were created successfully - bool IsOk() const { return m_fds[Read] != INVALID_FD; } - - // return the descriptor for one of the pipe ends - int operator[](Direction which) const - { - wxASSERT_MSG( which >= 0 && (size_t)which < WXSIZEOF(m_fds), - _T("invalid pipe index") ); - - return m_fds[which]; - } - - // detach a descriptor, meaning that the pipe dtor won't close it, and - // return it - int Detach(Direction which) - { - wxASSERT_MSG( which >= 0 && (size_t)which < WXSIZEOF(m_fds), - _T("invalid pipe index") ); - - int fd = m_fds[which]; - m_fds[which] = INVALID_FD; - - return fd; - } - - // close the pipe descriptors - void Close() - { - for ( size_t n = 0; n < WXSIZEOF(m_fds); n++ ) - { - if ( m_fds[n] != INVALID_FD ) - close(m_fds[n]); - } - } - - // dtor closes the pipe descriptors - ~wxPipe() { Close(); } - -private: - int m_fds[2]; -}; - // ---------------------------------------------------------------------------- // wxExecute: the real worker function // ---------------------------------------------------------------------------- @@ -532,10 +440,21 @@ long wxExecute(wxChar **argv, wxChar **mb_argv = argv; #endif // Unicode/ANSI -#if wxUSE_GUI + // we want this function to work even if there is no wxApp so ensure that + // we have a valid traits pointer + wxConsoleAppTraits traitsConsole; + wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; + if ( !traits ) + traits = &traitsConsole; + + // this struct contains all information which we pass to and from + // wxAppTraits methods + wxExecuteData execData; + execData.flags = flags; + execData.process = process; + // create pipes - wxPipe pipeEndProcDetect; - if ( !pipeEndProcDetect.Create() ) + if ( !traits->CreateEndProcessPipe(execData) ) { wxLogError( _("Failed to execute '%s'\n"), *argv ); @@ -543,7 +462,6 @@ long wxExecute(wxChar **argv, return ERROR_RETURN_CODE; } -#endif // wxUSE_GUI // pipes for inter process communication wxPipe pipeIn, // stdin @@ -594,10 +512,7 @@ long wxExecute(wxChar **argv, if ( fd == pipeIn[wxPipe::Read] || fd == pipeOut[wxPipe::Write] || fd == pipeErr[wxPipe::Write] -#if wxUSE_GUI - || fd == pipeEndProcDetect[wxPipe::Write] -#endif // wxUSE_GUI - ) + || traits->IsWriteFDOfEndProcessPipe(execData, fd) ) { // don't close this one, we still need it continue; @@ -618,12 +533,9 @@ long wxExecute(wxChar **argv, } #endif // !__VMS -#if wxUSE_GUI // reading side can be safely closed but we should keep the write one // opened - pipeEndProcDetect.Detach(wxPipe::Write); - pipeEndProcDetect.Close(); -#endif // wxUSE_GUI + traits->DetachWriteFDOfEndProcessPipe(execData); // redirect stdin, stdout and stderr if ( pipeIn.IsOk() ) @@ -642,6 +554,12 @@ long wxExecute(wxChar **argv, execvp (*mb_argv, mb_argv); + fprintf(stderr, "execvp("); + // CS changed ppc to ppc_ as ppc is not available under mac os CW Mach-O + for ( char **ppc_ = mb_argv; *ppc_; ppc_++ ) + fprintf(stderr, "%s%s", ppc_ == mb_argv ? "" : ", ", *ppc_); + fprintf(stderr, ") failed with error %d!\n", errno); + // there is no return after successful exec() _exit(-1); @@ -659,6 +577,9 @@ long wxExecute(wxChar **argv, { ARGS_CLEANUP; + // save it for WaitForChild() use + execData.pid = pid; + // prepare for IO redirection #if wxUSE_STREAMS @@ -684,6 +605,9 @@ long wxExecute(wxChar **argv, bufOut.Init(outStream); bufErr.Init(errStream); + + execData.bufOut = &bufOut; + execData.bufErr = &bufErr; #endif // wxUSE_STREAMS } @@ -694,72 +618,7 @@ long wxExecute(wxChar **argv, pipeErr.Close(); } -#if wxUSE_GUI && !defined(__WXMICROWIN__) - wxEndProcessData *data = new wxEndProcessData; - - data->tag = wxAddProcessCallback - ( - data, - pipeEndProcDetect.Detach(wxPipe::Read) - ); - - pipeEndProcDetect.Close(); - - if ( flags & wxEXEC_SYNC ) - { - // we may have process for capturing the program output, but it's - // not used in wxEndProcessData in the case of sync execution - data->process = NULL; - - // sync execution: indicate it by negating the pid - data->pid = -pid; - - wxBusyCursor bc; - wxWindowDisabler wd; - - // data->pid will be set to 0 from GTK_EndProcessDetector when the - // process terminates - while ( data->pid != 0 ) - { -#if wxUSE_STREAMS - bufOut.Update(); - bufErr.Update(); -#endif // wxUSE_STREAMS - - // give GTK+ a chance to call GTK_EndProcessDetector here and - // also repaint the GUI - wxYield(); - } - - int exitcode = data->exitcode; - - delete data; - - return exitcode; - } - else // async execution - { - // async execution, nothing special to do - caller will be - // notified about the process termination if process != NULL, data - // will be deleted in GTK_EndProcessDetector - data->process = process; - data->pid = pid; - - return pid; - } -#else // !wxUSE_GUI - - wxASSERT_MSG( flags & wxEXEC_SYNC, - wxT("async execution not supported yet") ); - - int exitcode = 0; - if ( waitpid(pid, &exitcode, 0) == -1 || !WIFEXITED(exitcode) ) - { - wxLogSysError(_("Waiting for subprocess termination failed")); - } - - return exitcode; -#endif // wxUSE_GUI + return traits->WaitForChild(execData); } return ERROR_RETURN_CODE; @@ -804,7 +663,12 @@ char *wxGetUserHome( const wxString &user ) if ((ptr = wxGetenv(wxT("HOME"))) != NULL) { +#if wxUSE_UNICODE + wxWCharBuffer buffer( ptr ); + return buffer; +#else return ptr; +#endif } if ((ptr = wxGetenv(wxT("USER"))) != NULL || (ptr = wxGetenv(wxT("LOGNAME"))) != NULL) { @@ -945,41 +809,19 @@ bool wxGetUserName(wxChar *buf, int sz) return FALSE; } +// this function is in mac/utils.cpp for wxMac #ifndef __WXMAC__ + wxString wxGetOsDescription() { #ifndef WXWIN_OS_DESCRIPTION #error WXWIN_OS_DESCRIPTION should be defined in config.h by configure #else - return WXWIN_OS_DESCRIPTION; + return wxString::FromAscii( WXWIN_OS_DESCRIPTION ); #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 +#endif // !__WXMAC__ unsigned long wxGetProcessId() { @@ -1019,8 +861,8 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree) { #if defined(HAVE_STATFS) || defined(HAVE_STATVFS) // the case to "char *" is needed for AIX 4.3 - wxStatFs fs; - if ( statfs((char *)(const char*)path.fn_str(), &fs) != 0 ) + wxStatfs_t fs; + if ( wxStatfs((char *)(const char*)path.fn_str(), &fs) != 0 ) { wxLogSysError( wxT("Failed to get file system statistics") ); @@ -1202,3 +1044,150 @@ void wxFatalError( const wxString &msg, const wxString &title ) #endif // WXWIN_COMPATIBILITY_2_2 +#endif // wxUSE_BASE + +#if wxUSE_GUI + +// ---------------------------------------------------------------------------- +// wxExecute support +// ---------------------------------------------------------------------------- + +// Darwin doesn't use the same process end detection mechanisms so we don't +// need wxExecute-related helpers for it +#if !(defined(__DARWIN__) && defined(__WXMAC__)) + +bool wxGUIAppTraits::CreateEndProcessPipe(wxExecuteData& execData) +{ + return execData.pipeEndProcDetect.Create(); +} + +bool wxGUIAppTraits::IsWriteFDOfEndProcessPipe(wxExecuteData& execData, int fd) +{ + return fd == (execData.pipeEndProcDetect)[wxPipe::Write]; +} + +void wxGUIAppTraits::DetachWriteFDOfEndProcessPipe(wxExecuteData& execData) +{ + execData.pipeEndProcDetect.Detach(wxPipe::Write); + execData.pipeEndProcDetect.Close(); +} + +#else // !Darwin + +bool wxGUIAppTraits::CreateEndProcessPipe(wxExecuteData& WXUNUSED(execData)) +{ + return true; +} + +bool +wxGUIAppTraits::IsWriteFDOfEndProcessPipe(wxExecuteData& WXUNUSED(execData), + int WXUNUSED(fd)) +{ + return false; +} + +void +wxGUIAppTraits::DetachWriteFDOfEndProcessPipe(wxExecuteData& WXUNUSED(execData)) +{ + // nothing to do here, we don't use the pipe +} + +#endif // !Darwin/Darwin + +int wxGUIAppTraits::WaitForChild(wxExecuteData& execData) +{ + wxEndProcessData *endProcData = new wxEndProcessData; + + // wxAddProcessCallback is now (with DARWIN) allowed to call the + // callback function directly if the process terminates before + // the callback can be added to the run loop. Set up the endProcData. + if ( execData.flags & wxEXEC_SYNC ) + { + // we may have process for capturing the program output, but it's + // not used in wxEndProcessData in the case of sync execution + endProcData->process = NULL; + + // sync execution: indicate it by negating the pid + endProcData->pid = -execData.pid; + } + else + { + // async execution, nothing special to do -- caller will be + // notified about the process termination if process != NULL, endProcData + // will be deleted in GTK_EndProcessDetector + endProcData->process = execData.process; + endProcData->pid = execData.pid; + } + + +#if defined(__DARWIN__) && defined(__WXMAC__) + endProcData->tag = wxAddProcessCallbackForPid(endProcData, execData.pid); +#else + endProcData->tag = wxAddProcessCallback + ( + endProcData, + execData.pipeEndProcDetect.Detach(wxPipe::Read) + ); + + execData.pipeEndProcDetect.Close(); +#endif // defined(__DARWIN__) && defined(__WXMAC__) + + if ( execData.flags & wxEXEC_SYNC ) + { + wxBusyCursor bc; + wxWindowDisabler wd; + + // endProcData->pid will be set to 0 from GTK_EndProcessDetector when the + // process terminates + while ( endProcData->pid != 0 ) + { +#if wxUSE_STREAMS + if ( execData.bufOut ) + execData.bufOut->Update(); + + if ( execData.bufErr ) + execData.bufErr->Update(); +#endif // wxUSE_STREAMS + + // give GTK+ a chance to call GTK_EndProcessDetector here and + // also repaint the GUI + wxYield(); + } + + int exitcode = endProcData->exitcode; + + delete endProcData; + + return exitcode; + } + else // async execution + { + return execData.pid; + } +} + +#endif // wxUSE_GUI +#if wxUSE_BASE + +void wxHandleProcessTermination(wxEndProcessData *proc_data) +{ + // notify user about termination if required + if ( proc_data->process ) + { + proc_data->process->OnTerminate(proc_data->pid, proc_data->exitcode); + } + + // clean up + if ( proc_data->pid > 0 ) + { + delete proc_data; + } + else + { + // let wxExecute() know that the process has terminated + proc_data->pid = 0; + } +} + + +#endif // wxUSE_BASE